| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License") + you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openmeetings.data.calendar.management; |
| |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TimeZone; |
| |
| import org.apache.openmeetings.data.basic.FieldManager; |
| import org.apache.openmeetings.data.basic.dao.ConfigurationDao; |
| import org.apache.openmeetings.data.basic.dao.OmTimeZoneDao; |
| import org.apache.openmeetings.data.calendar.daos.AppointmentDao; |
| import org.apache.openmeetings.data.calendar.daos.MeetingMemberDao; |
| import org.apache.openmeetings.data.conference.InvitationManager; |
| import org.apache.openmeetings.data.conference.RoomManager; |
| import org.apache.openmeetings.data.conference.dao.RoomDao; |
| import org.apache.openmeetings.data.user.UserManager; |
| import org.apache.openmeetings.persistence.beans.basic.OmTimeZone; |
| import org.apache.openmeetings.persistence.beans.calendar.Appointment; |
| import org.apache.openmeetings.persistence.beans.calendar.MeetingMember; |
| import org.apache.openmeetings.persistence.beans.invitation.Invitations; |
| import org.apache.openmeetings.persistence.beans.lang.Fieldlanguagesvalues; |
| import org.apache.openmeetings.persistence.beans.room.Room; |
| import org.apache.openmeetings.persistence.beans.user.User; |
| import org.apache.openmeetings.utils.math.CalendarPatterns; |
| import org.apache.openmeetings.utils.math.TimezoneUtil; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| |
| public class AppointmentLogic { |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| AppointmentLogic.class, "openmeetings"); |
| |
| @Autowired |
| private AppointmentDao appointmentDao; |
| @Autowired |
| private ConfigurationDao configurationDao; |
| @Autowired |
| private UserManager userManager; |
| @Autowired |
| private FieldManager fieldManager; |
| @Autowired |
| private OmTimeZoneDao omTimeZoneDaoImpl; |
| @Autowired |
| private RoomManager roomManager; |
| @Autowired |
| private RoomDao roomDao; |
| @Autowired |
| private InvitationManager invitationManager; |
| @Autowired |
| private MeetingMemberDao meetingMemberDao; |
| @Autowired |
| private MeetingMemberLogic meetingMemberLogic; |
| @Autowired |
| private TimezoneUtil timezoneUtil; |
| |
| private static int DEFAULT_MINUTES_REMINDER_SEND = 15; |
| |
| public List<Appointment> getAppointmentByRange(Long userId, Date starttime, |
| Date endtime) { |
| try { |
| return appointmentDao.getAppointmentsByRange(userId, starttime, |
| endtime); |
| } catch (Exception err) { |
| log.error("[getAppointmentByRange]", err); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getTodaysAppointmentsForUser(Long userId) { |
| log.debug("getTodaysAppointmentsForUser"); |
| |
| List<Appointment> points = appointmentDao |
| .getTodaysAppointmentsbyRangeAndMember(userId); |
| |
| log.debug("Count Appointments for Today : " + points.size()); |
| |
| return points; |
| |
| } |
| |
| /** |
| * @author o.becherer |
| * @param room_id |
| * @return |
| */ |
| // -------------------------------------------------------------------------------------------- |
| public Appointment getAppointmentByRoom(Long room_id) throws Exception { |
| log.debug("getAppointmentByRoom"); |
| |
| Room room = roomDao.get(room_id); |
| |
| if (room == null) |
| throw new Exception("Room does not exist in database!"); |
| |
| if (!room.getAppointment()) |
| throw new Exception("Room " + room.getName() |
| + " isnt part of an appointed meeting"); |
| |
| return appointmentDao.getAppointmentByRoom(room_id); |
| } |
| |
| // -------------------------------------------------------------------------------------------- |
| |
| // next appointment to current date |
| public Appointment getNextAppointment() { |
| try { |
| return appointmentDao.getNextAppointment(new Date()); |
| } catch (Exception err) { |
| log.error("[getNextAppointmentById]", err); |
| } |
| return null; |
| } |
| |
| public List<Appointment> searchAppointmentByName(String appointmentName) { |
| try { |
| return appointmentDao.searchAppointmentsByName(appointmentName); |
| } catch (Exception err) { |
| log.error("[searchAppointmentByName]", err); |
| } |
| return null; |
| } |
| |
| public Long saveAppointment(String appointmentName, Long userId, |
| String appointmentLocation, String appointmentDescription, |
| Date appointmentstart, Date appointmentend, |
| Boolean isDaily, Boolean isWeekly, Boolean isMonthly, |
| Boolean isYearly, Long categoryId, Long remind, |
| @SuppressWarnings("rawtypes") List mmClient, Long roomType, |
| String baseUrl, Long language_id, Boolean isPasswordProtected, |
| String password, long roomId) { |
| |
| log.debug("Appointmentlogic.saveAppointment"); |
| |
| // TODO:Add this user as the default Moderator of the Room |
| |
| Long numberOfParticipants = configurationDao.getConfValue( |
| "calendar.conference.rooms.default.size", Long.class, "50"); |
| |
| try { |
| |
| // Adding creator as MeetingMember |
| User user = userManager.getUserById(userId); |
| |
| Long room_id = roomId > 0 ? roomId : roomManager.addRoom(3, // user level |
| appointmentName, // name |
| roomType, // RoomType |
| "", // Comment |
| numberOfParticipants, // Number of participants |
| true, // public |
| null, // organizations |
| true, // Appointment |
| false, // Demo Room => Meeting Timer |
| null, // Meeting Timer time in seconds |
| false, // Is Moderated Room |
| null, // Moderation List Room |
| true, // Allow User Questions |
| false, // isAudioOnly |
| true, // allowFontStyles |
| false, // isClosed |
| "", // redirectURL |
| "", // conferencePIN |
| null, // ownerID |
| null, null, |
| false, // hideTopBar |
| false, // hideChat |
| false, // hideActivitiesAndActions |
| false, // hideFilesExplorer |
| false, // hideActionsMenu |
| false, // hideScreenSharing |
| false, // hideWhiteboard |
| false, //showMicrophoneStatus |
| false, // chatModerated |
| false, // chatOpened |
| false, // filesOpened |
| false, // autoVideoSelect |
| false //sipEnabled |
| ); |
| |
| log.debug("Appointmentlogic.saveAppointment : Room - " + room_id); |
| log.debug("Appointmentlogic.saveAppointment : Reminder - " + remind); |
| |
| Room room = roomDao.get(room_id); |
| |
| // Re-factor the given time ignoring the Date is always UTC! |
| TimeZone timezone = timezoneUtil.getTimezoneByUser(user); |
| |
| Long appointmentId = appointmentDao.addAppointment(appointmentName, |
| userId, appointmentLocation, appointmentDescription, |
| appointmentstart, appointmentend, isDaily, isWeekly, |
| isMonthly, isYearly, categoryId, remind, room, language_id, |
| isPasswordProtected, password, false, user.getOmTimeZone().getJname()); |
| |
| String invitorName = user.getFirstname() + " " + user.getLastname() |
| + " [" + user.getAdresses().getEmail() + "]"; |
| |
| // Add the creator of the meeting calendar event |
| meetingMemberLogic.addMeetingMember(user.getFirstname(), user |
| .getLastname(), "", "", appointmentId, userId, user |
| .getAdresses().getEmail(), user.getPhoneForSMS(), baseUrl, userId, true, |
| language_id, isPasswordProtected, password, timezone, user.getOmTimeZone(), |
| invitorName); |
| |
| // iterate through all members of this meeting and add them to the |
| // event and send invitation |
| if (mmClient != null) { |
| |
| for (int i = 0; i < mmClient.size(); i++) { |
| |
| @SuppressWarnings("rawtypes") |
| Map clientMember = (Map) mmClient.get(i); |
| |
| log.debug("clientMember.get('userId') " |
| + clientMember.get("userId")); |
| |
| for (Object tString : clientMember.entrySet()) { |
| log.debug("tString " + tString); |
| } |
| log.debug("clientMember.get('meetingMemberId') " |
| + clientMember.get("meetingMemberId")); |
| |
| // We need two different timeZones, the internal Java Object |
| // TimeZone, and |
| // the one for the UI display object to map to, cause the UI |
| // only has around 24 timezones |
| // and Java around 600++ |
| Long sendToUserId = 0L; |
| TimeZone timezoneMember = null; |
| OmTimeZone omTimeZone = null; |
| if (clientMember.get("userId") != null) { |
| sendToUserId = Long.valueOf( |
| clientMember.get("userId").toString()) |
| .longValue(); |
| } |
| |
| String phone = ""; |
| // Check if this is an internal user, if yes use the |
| // timezone from his profile otherwise get the timezones |
| // from the variable jNameTimeZone |
| if (sendToUserId > 0) { |
| User interalUser = userManager |
| .getUserById(sendToUserId); |
| phone = interalUser.getPhoneForSMS(); |
| timezoneMember = timezoneUtil |
| .getTimezoneByUser(interalUser); |
| omTimeZone = interalUser.getOmTimeZone(); |
| } else { |
| // Get the internal-name of the timezone set in the |
| // client object and convert it to a real one |
| Object jName = clientMember.get("jNameTimeZone"); |
| if (jName == null) { |
| log.error("jNameTimeZone not set in user object variable"); |
| jName = ""; |
| } |
| omTimeZone = omTimeZoneDaoImpl.getOmTimeZone(jName |
| .toString()); |
| timezoneMember = timezoneUtil |
| .getTimezoneByInternalJName(jName.toString()); |
| } |
| |
| // Not In Remote List available - intern OR extern user |
| meetingMemberLogic.addMeetingMember( |
| clientMember.get("firstname").toString(), |
| clientMember.get("lastname").toString(), |
| "0", // memberStatus |
| "0", // appointmentStatus |
| appointmentId, |
| sendToUserId, // sending To: External users have a 0 |
| // here |
| clientMember.get("email").toString(), |
| phone, |
| baseUrl, |
| userId, // meeting_organizer |
| new Boolean(false), // invitor |
| language_id, //language_id |
| isPasswordProtected, // isPasswordProtected |
| password, // password |
| timezoneMember, omTimeZone, invitorName); |
| |
| } |
| } |
| |
| return appointmentId; |
| } catch (Exception err) { |
| log.error("[saveAppointment]", err); |
| } |
| return null; |
| } |
| |
| /** |
| * |
| * @param appointmentId |
| * @return |
| */ |
| // ------------------------------------------------------------------------------------- |
| public Long deleteAppointment(Long appointmentId, Long users_id, |
| Long language_id) { |
| log.debug("deleteAppointment : " + appointmentId); |
| |
| try { |
| |
| Appointment point = getAppointMentById(appointmentId); |
| |
| if (point == null) { |
| log.error("No appointment found for ID " + appointmentId); |
| return null; |
| } |
| |
| if (point.getIsConnectedEvent() != null |
| && point.getIsConnectedEvent()) { |
| List<Appointment> appointments = appointmentDao |
| .getAppointmentsByRoomId(point.getRoom().getRooms_id()); |
| |
| for (Appointment appointment : appointments) { |
| |
| if (!appointment.getAppointmentId().equals(appointmentId)) { |
| |
| appointmentDao.deleteAppointement(appointment |
| .getAppointmentId()); |
| |
| } |
| |
| } |
| |
| } |
| |
| Room room = point.getRoom(); |
| |
| // Deleting/Notifing Meetingmembers |
| List<MeetingMember> members = meetingMemberDao |
| .getMeetingMemberByAppointmentId(appointmentId); |
| |
| if (members == null) |
| log.debug("Appointment " + point.getAppointmentName() |
| + " has no meeting members"); |
| |
| if (members != null) { |
| for (int i = 0; i < members.size(); i++) { |
| log.debug("deleting member " + members.get(i).getEmail()); |
| meetingMemberLogic.deleteMeetingMember(members.get(i) |
| .getMeetingMemberId(), users_id, language_id); |
| } |
| } |
| |
| // Deleting Appointment itself |
| appointmentDao.deleteAppointement(appointmentId); |
| |
| // Deleting Room |
| boolean isAppRoom = room.getAppointment(); |
| if (isAppRoom) { |
| roomDao.delete(room, users_id); |
| } |
| |
| return appointmentId; |
| |
| } catch (Exception err) { |
| log.error("[deleteAppointment]", err); |
| } |
| |
| return null; |
| |
| } |
| |
| // ------------------------------------------------------------------------------------- |
| |
| /** |
| * Retrieving Appointment by ID |
| */ |
| // ---------------------------------------------------------------------------------------------- |
| public Appointment getAppointMentById(Long appointment) { |
| log.debug("getAppointMentById"); |
| |
| return appointmentDao.getAppointmentById(appointment); |
| } |
| |
| // ---------------------------------------------------------------------------------------------- |
| |
| /** |
| * Sending Reminder in Simple mail format 5 minutes before Meeting begins |
| */ |
| // ---------------------------------------------------------------------------------------------- |
| public void doScheduledMeetingReminder() throws Exception { |
| // log.debug("doScheduledMeetingReminder"); |
| |
| Integer minutesReminderSend = configurationDao.getConfValue( |
| "number.minutes.reminder.send", Integer.class, "" |
| + DEFAULT_MINUTES_REMINDER_SEND); |
| if (minutesReminderSend == null) { |
| throw new Exception("minutesReminderSend is null!"); |
| } |
| |
| if (minutesReminderSend == 0) { |
| log.warn("minutesReminderSend is 0, disabling reminder scheduler"); |
| return; |
| } |
| |
| long millisecondsToCheck = (minutesReminderSend * 60 * 1000); |
| |
| List<Appointment> points = appointmentDao |
| .getAppointmentsForAllUsersByTimeRangeStartingNow( |
| millisecondsToCheck, false); |
| |
| if (points == null || points.size() < 1) { |
| log.debug("doScheduledMeetingReminder : no Appointments in range"); |
| return; |
| } |
| |
| Long language_id = configurationDao.getConfValue("default_lang_id", Long.class, "1"); |
| |
| // Get the required labels one time for all meeting members. The |
| // Language of the email will be the system default language |
| String labelid1158 = fieldManager.getString(1158L, language_id); |
| Fieldlanguagesvalues labelid1153 = fieldManager |
| .getFieldByIdAndLanguage(1153L, language_id); |
| Fieldlanguagesvalues labelid1154 = fieldManager |
| .getFieldByIdAndLanguage(1154L, language_id); |
| |
| for (int i = 0; i < points.size(); i++) { |
| Appointment ment = points.get(i); |
| |
| // Prevent email from being send twice, even if the cycle takes |
| // very long to send each |
| if (ment.getIsReminderEmailSend() != null |
| && ment.getIsReminderEmailSend()) { |
| continue; |
| } |
| |
| // Checking ReminderType - only ReminderType simple mail is |
| // concerned! |
| if (ment.getRemind().getTypId() == 2 |
| || ment.getRemind().getTypId() == 3) { |
| |
| // Update Appointment to not send invitation twice |
| ment.setIsReminderEmailSend(true); |
| appointmentDao.updateAppointment(ment); |
| |
| List<MeetingMember> members = meetingMemberDao |
| .getMeetingMemberByAppointmentId(ment |
| .getAppointmentId()); |
| |
| if (members == null) { |
| log.debug("doScheduledMeetingReminder : no members in meeting!"); |
| continue; |
| } |
| |
| // Iterate through all MeetingMembers |
| for (MeetingMember mm : members) { |
| |
| log.debug("doScheduledMeetingReminder : Member " |
| + mm.getEmail()); |
| |
| Invitations inv = mm.getInvitation(); |
| |
| if (inv == null) { |
| log.error("Error retrieving Invitation for member " |
| + mm.getEmail() + " in Appointment " |
| + ment.getAppointmentName()); |
| continue; |
| } |
| |
| if (inv.getBaseUrl() == null |
| || inv.getBaseUrl().length() < 1) { |
| log.error("Error retrieving baseUrl from Invitation ID : " |
| + inv.getInvitations_id()); |
| continue; |
| } |
| |
| TimeZone tZone = null; |
| |
| if (mm.getOmTimeZone() != null) { |
| tZone = timezoneUtil.getTimezoneByOmTimeZoneId(mm |
| .getOmTimeZone().getOmtimezoneId()); |
| } else { |
| tZone = TimeZone.getDefault(); |
| } |
| |
| String subject = generateSubject(labelid1158, ment, tZone); |
| String smsSubject = generateSMSSubject(labelid1158, ment); |
| |
| String message = generateMessage(labelid1158, ment, |
| language_id, labelid1153, labelid1154, tZone); |
| |
| invitationManager.sendInvitationReminderLink(language_id, message, |
| inv.getBaseUrl(), mm.getEmail(), subject, |
| inv.getHash()); |
| |
| invitationManager.sendInvitationReminderSMS(mm.getPhone(), smsSubject, language_id); |
| inv.setUpdatetime(new Date()); |
| invitationManager.updateInvitation(inv); |
| } |
| } |
| } |
| } |
| |
| private String generateSubject(String labelid1158, |
| Appointment ment, TimeZone timezone) { |
| |
| String message = labelid1158 + " " |
| + ment.getAppointmentName(); |
| |
| message += ' ' + CalendarPatterns |
| .getDateWithTimeByMiliSecondsAndTimeZone( |
| ment.getAppointmentStarttime(), timezone); |
| |
| message += " - " |
| + CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone( |
| ment.getAppointmentEndtime(), timezone); |
| |
| return message; |
| |
| } |
| |
| private String generateSMSSubject(String labelid1158, Appointment ment) { |
| String subj = configurationDao.getConfValue("sms.subject", String.class, null); |
| return subj == null || subj.length() == 0 ? |
| labelid1158 + " " + ment.getAppointmentName() : subj; |
| } |
| |
| /** |
| * Generate a localized message including the time and date of the meeting |
| * event |
| * |
| * @param labelid1158 |
| * @param ment |
| * @param language_id |
| * @param labelid1153 |
| * @param jNameTimeZone |
| * @param labelid1154 |
| * @return |
| */ |
| private String generateMessage(String labelid1158, |
| Appointment ment, Long language_id, |
| Fieldlanguagesvalues labelid1153, Fieldlanguagesvalues labelid1154, |
| TimeZone timezone) { |
| |
| String message = labelid1158 + " " |
| + ment.getAppointmentName(); |
| |
| if (ment.getAppointmentDescription().length() != 0) { |
| |
| Fieldlanguagesvalues labelid1152 = fieldManager |
| .getFieldByIdAndLanguage(new Long(1152), language_id); |
| message += labelid1152.getValue() |
| + ment.getAppointmentDescription(); |
| |
| } |
| |
| message += "<br/>" |
| + labelid1153.getValue() |
| + ' ' |
| + CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone( |
| ment.getAppointmentStarttime(), timezone) + "<br/>"; |
| |
| message += labelid1154.getValue() |
| + ' ' |
| + CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone( |
| ment.getAppointmentEndtime(), timezone) + "<br/>"; |
| |
| return message; |
| } |
| |
| } |