| /* |
| * 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.daos; |
| |
| import java.sql.Timestamp; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TimeZone; |
| |
| import javax.persistence.EntityManager; |
| import javax.persistence.NoResultException; |
| import javax.persistence.PersistenceContext; |
| import javax.persistence.TypedQuery; |
| import javax.persistence.criteria.CriteriaBuilder; |
| import javax.persistence.criteria.CriteriaQuery; |
| import javax.persistence.criteria.Predicate; |
| import javax.persistence.criteria.Root; |
| |
| import org.apache.openmeetings.OpenmeetingsVariables; |
| import org.apache.openmeetings.data.basic.dao.OmTimeZoneDao; |
| import org.apache.openmeetings.data.calendar.management.MeetingMemberLogic; |
| import org.apache.openmeetings.data.conference.InvitationManager; |
| import org.apache.openmeetings.data.user.UserManager; |
| import org.apache.openmeetings.data.user.dao.UsersDao; |
| import org.apache.openmeetings.persistence.beans.basic.OmTimeZone; |
| import org.apache.openmeetings.persistence.beans.calendar.Appointment; |
| import org.apache.openmeetings.persistence.beans.calendar.AppointmentCategory; |
| import org.apache.openmeetings.persistence.beans.calendar.AppointmentReminderTyps; |
| import org.apache.openmeetings.persistence.beans.calendar.MeetingMember; |
| 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; |
| import org.springframework.transaction.annotation.Transactional; |
| |
| @Transactional |
| public class AppointmentDao { |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| AppointmentDao.class, OpenmeetingsVariables.webAppRootKey); |
| @PersistenceContext |
| private EntityManager em; |
| @Autowired |
| private UserManager userManager; |
| @Autowired |
| private OmTimeZoneDao omTimeZoneDaoImpl; |
| @Autowired |
| private AppointmentCategoryDao appointmentCategoryDaoImpl; |
| @Autowired |
| private AppointmentReminderTypDao appointmentReminderTypDaoImpl; |
| @Autowired |
| private MeetingMemberDao meetingMemberDao; |
| @Autowired |
| private UsersDao usersDao; |
| @Autowired |
| private InvitationManager invitationManager; |
| @Autowired |
| private MeetingMemberLogic meetingMemberLogic; |
| @Autowired |
| private TimezoneUtil timezoneUtil; |
| |
| /* |
| * insert, update, delete, select |
| */ |
| |
| /** |
| * @author o.becherer Retrievment of Appointment for room |
| */ |
| // ----------------------------------------------------------------------------------------------- |
| public Appointment getAppointmentByRoom(Long room_id) throws Exception { |
| log.debug("AppointMentDaoImpl.getAppointmentByRoom"); |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.room.rooms_id = :room_id "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("room_id", room_id); |
| |
| List<Appointment> appoint = query.getResultList(); |
| |
| if (appoint.size() > 0) { |
| return appoint.get(0); |
| } |
| |
| return null; |
| } |
| |
| // ----------------------------------------------------------------------------------------------- |
| |
| public Appointment getAppointmentById(Long appointmentId) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.appointmentId = :appointmentId "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("appointmentId", appointmentId); |
| |
| Appointment appoint = null; |
| try { |
| appoint = query.getSingleResult(); |
| } catch (NoResultException ex) { |
| } |
| return appoint; |
| } catch (Exception ex2) { |
| log.error("[getAppointmentById]: ", ex2); |
| } |
| return null; |
| } |
| |
| public Appointment getAppointmentByIdBackup(Long appointmentId) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.appointmentId = :appointmentId "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, Appointment.class); |
| query.setParameter("appointmentId", appointmentId); |
| |
| Appointment appoint = null; |
| try { |
| appoint = query.getSingleResult(); |
| } catch (NoResultException ex) { |
| } |
| |
| return appoint; |
| } catch (Exception ex2) { |
| log.error("[getAppointmentById]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getAppointments() { |
| try { |
| TypedQuery<Appointment> query = em.createQuery( |
| "SELECT a FROM Appointment a LEFT JOIN FETCH a.meetingMember WHERE a.deleted <> :deleted " |
| , Appointment.class); |
| query.setParameter("deleted", true); |
| |
| return query.getResultList(); |
| } catch (Exception ex2) { |
| log.error("[getAppointmentById]: ", ex2); |
| } |
| return null; |
| } |
| |
| /** |
| * |
| * @param appointmentName |
| * @param userId |
| * @param appointmentLocation |
| * @param appointmentDescription |
| * @param appointmentstart |
| * @param appointmentend |
| * @param isDaily |
| * @param isWeekly |
| * @param isMonthly |
| * @param isYearly |
| * @param categoryId |
| * @param remind |
| * @param room |
| * @return |
| */ |
| // ---------------------------------------------------------------------------------------------------------------------------- |
| public Long addAppointment(String appointmentName, Long userId, |
| String appointmentLocation, String appointmentDescription, |
| Date appointmentstart, Date appointmentend, Boolean isDaily, |
| Boolean isWeekly, Boolean isMonthly, Boolean isYearly, |
| Long categoryId, Long remind, Room room, Long language_id, |
| Boolean isPasswordProtected, String password, |
| Boolean isConnectedEvent, String jNameTimeZone) { |
| try { |
| |
| Appointment ap = new Appointment(); |
| |
| ap.setAppointmentName(appointmentName); |
| ap.setAppointmentLocation(appointmentLocation); |
| |
| log.debug("addAppointment appointmentstart :1: " |
| + CalendarPatterns |
| .getDateWithTimeByMiliSecondsWithZone(appointmentstart)); |
| log.debug("addAppointment appointmentend :1: " |
| + CalendarPatterns |
| .getDateWithTimeByMiliSecondsWithZone(appointmentend)); |
| |
| ap.setAppointmentStarttime(appointmentstart); |
| ap.setAppointmentEndtime(appointmentend); |
| ap.setAppointmentDescription(appointmentDescription); |
| ap.setRemind(appointmentReminderTypDaoImpl |
| .getAppointmentReminderTypById(remind)); |
| ap.setStarttime(new Date()); |
| ap.setIsReminderEmailSend(false); |
| ap.setDeleted(false); |
| ap.setIsDaily(isDaily); |
| ap.setIsWeekly(isWeekly); |
| ap.setIsMonthly(isMonthly); |
| ap.setIsYearly(isYearly); |
| ap.setLanguage_id(language_id); |
| ap.setIsPasswordProtected(isPasswordProtected); |
| ap.setPassword(password); |
| ap.setUserId(usersDao.get(userId)); |
| ap.setAppointmentCategory(appointmentCategoryDaoImpl |
| .getAppointmentCategoryById(categoryId)); |
| ap.setRoom(room); |
| ap.setIsConnectedEvent(isConnectedEvent); |
| |
| ap = em.merge(ap); |
| |
| return ap.getAppointmentId(); |
| } catch (Exception ex2) { |
| log.error("[addAppointment]: ", ex2); |
| } |
| return null; |
| } |
| |
| public Long addAppointmentObj(Appointment ap) { |
| try { |
| |
| ap.setStarttime(new Date()); |
| |
| ap = em.merge(ap); |
| |
| return ap.getAppointmentId(); |
| } catch (Exception ex2) { |
| log.error("[addAppointmentObj]: ", ex2); |
| } |
| return null; |
| } |
| |
| // ---------------------------------------------------------------------------------------------------------------------------- |
| |
| public Long updateAppointment(Appointment appointment) { |
| if (appointment.getAppointmentId() > 0) { |
| try { |
| if (appointment.getAppointmentId() == null) { |
| em.persist(appointment); |
| } else { |
| if (!em.contains(appointment)) { |
| em.merge(appointment); |
| } |
| } |
| return appointment.getAppointmentId(); |
| } catch (Exception ex2) { |
| log.error("[updateAppointment] ", ex2); |
| } |
| } else { |
| log.error("[updateAppointment] " + "Error: No AppointmentId given"); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getAppointmentsByRoomId(Long roomId) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.room.rooms_id = :roomId "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| query.setParameter("roomId", roomId); |
| List<Appointment> ll = query.getResultList(); |
| |
| return ll; |
| } catch (Exception e) { |
| log.error("[getAppointmentsByRoomId]", e); |
| } |
| return null; |
| } |
| |
| private void updateConnectedEventsTimeOnly(Appointment ap, |
| Date appointmentstart, Date appointmentend) { |
| try { |
| |
| if (ap.getRoom() == null) { |
| return; |
| } |
| |
| List<Appointment> appointments = this.getAppointmentsByRoomId(ap |
| .getRoom().getRooms_id()); |
| |
| for (Appointment appointment : appointments) { |
| |
| if (!ap.getAppointmentId().equals( |
| appointment.getAppointmentId())) { |
| |
| ap.setAppointmentStarttime(appointmentstart); |
| ap.setAppointmentEndtime(appointmentend); |
| ap.setUpdatetime(new Date()); |
| if (ap.getAppointmentId() == null) { |
| em.persist(ap); |
| } else { |
| if (!em.contains(ap)) { |
| em.merge(ap); |
| } |
| } |
| |
| } |
| |
| } |
| |
| } catch (Exception err) { |
| log.error("[updateConnectedEvents]", err); |
| } |
| } |
| |
| private void updateConnectedEvents(Appointment ap, String appointmentName, |
| String appointmentDescription, Date appointmentstart, |
| Date appointmentend, Boolean isDaily, Boolean isWeekly, |
| Boolean isMonthly, Boolean isYearly, |
| AppointmentCategory appointmentCategory, |
| AppointmentReminderTyps appointmentReminderTyps, @SuppressWarnings("rawtypes") List mmClient, |
| Long users_id, String baseUrl, Long language_id, |
| Boolean isPasswordProtected, String password) { |
| try { |
| |
| if (ap.getRoom() == null) { |
| return; |
| } |
| |
| List<Appointment> appointments = this.getAppointmentsByRoomId(ap |
| .getRoom().getRooms_id()); |
| |
| for (Appointment appointment : appointments) { |
| |
| if (!ap.getAppointmentId().equals( |
| appointment.getAppointmentId())) { |
| |
| appointment.setAppointmentName(appointmentName); |
| appointment.setAppointmentStarttime(appointmentstart); |
| appointment.setAppointmentEndtime(appointmentend); |
| appointment |
| .setAppointmentDescription(appointmentDescription); |
| appointment.setUpdatetime(new Date()); |
| appointment.setRemind(appointmentReminderTyps); |
| appointment.setIsDaily(isDaily); |
| appointment.setIsWeekly(isWeekly); |
| appointment.setIsMonthly(isMonthly); |
| appointment.setIsYearly(isYearly); |
| appointment.setLanguage_id(language_id); |
| appointment.setIsPasswordProtected(isPasswordProtected); |
| appointment.setPassword(password); |
| // ap.setUserId(usersDao.getUser(userId)); |
| appointment.setAppointmentCategory(appointmentCategory); |
| |
| if (appointment.getAppointmentId() == null) { |
| em.persist(appointment); |
| } else { |
| if (!em.contains(appointment)) { |
| em.merge(appointment); |
| } |
| } |
| |
| } |
| |
| } |
| |
| } catch (Exception err) { |
| log.error("[updateConnectedEvents]", err); |
| } |
| } |
| |
| /** |
| * |
| * @param appointmentId |
| * @param appointmentName |
| * @param appointmentDescription |
| * @param appointmentstart |
| * @param appointmentend |
| * @param isDaily |
| * @param isWeekly |
| * @param isMonthly |
| * @param isYearly |
| * @param categoryId |
| * @param remind |
| * @param mmClient |
| * @param users_id |
| * @return |
| */ |
| // ---------------------------------------------------------------------------------------------------------- |
| public Long updateAppointment(Long appointmentId, String appointmentName, |
| String appointmentDescription, Date appointmentstart, |
| Date appointmentend, Boolean isDaily, Boolean isWeekly, |
| Boolean isMonthly, Boolean isYearly, Long categoryId, Long remind, |
| @SuppressWarnings("rawtypes") List mmClient, Long users_id, String baseUrl, Long language_id, |
| Boolean isPasswordProtected, String password, String iCalTimeZone, String appointmentLocation) { |
| |
| log.debug("AppointmentDAOImpl.updateAppointment"); |
| try { |
| |
| Appointment ap = this.getAppointmentById(appointmentId); |
| |
| AppointmentReminderTyps appointmentReminderTyps = appointmentReminderTypDaoImpl |
| .getAppointmentReminderTypById(remind); |
| AppointmentCategory appointmentCategory = appointmentCategoryDaoImpl |
| .getAppointmentCategoryById(categoryId); |
| |
| boolean sendMail = !ap.getAppointmentName().equals(appointmentName) || |
| !ap.getAppointmentDescription().equals(appointmentDescription) || |
| !ap.getAppointmentLocation().equals(appointmentLocation) || |
| !ap.getAppointmentStarttime().equals(appointmentstart) || |
| !ap.getAppointmentEndtime().equals(appointmentend); |
| |
| // change connected events of other participants |
| if (ap.getIsConnectedEvent() != null && ap.getIsConnectedEvent()) { |
| this.updateConnectedEvents(ap, appointmentName, |
| appointmentDescription, appointmentstart, |
| appointmentend, isDaily, isWeekly, isMonthly, isYearly, |
| appointmentCategory, appointmentReminderTyps, mmClient, |
| users_id, baseUrl, language_id, isPasswordProtected, |
| password); |
| } |
| |
| // Update Invitation hash to new time |
| invitationManager.updateInvitationByAppointment(appointmentId, |
| appointmentstart, appointmentend); |
| |
| ap.setAppointmentName(appointmentName); |
| ap.setAppointmentLocation(appointmentLocation); |
| ap.setAppointmentStarttime(appointmentstart); |
| ap.setAppointmentEndtime(appointmentend); |
| ap.setAppointmentDescription(appointmentDescription); |
| ap.setUpdatetime(new Date()); |
| ap.setRemind(appointmentReminderTyps); |
| ap.setIsDaily(isDaily); |
| ap.setIsWeekly(isWeekly); |
| ap.setIsMonthly(isMonthly); |
| ap.setIsYearly(isYearly); |
| ap.setLanguage_id(language_id); |
| ap.setIsPasswordProtected(isPasswordProtected); |
| ap.setPassword(password); |
| // ap.setUserId(usersDao.getUser(userId)); |
| ap.setAppointmentCategory(appointmentCategory); |
| |
| if (ap.getAppointmentId() == null) { |
| em.persist(ap); |
| } else { |
| if (!em.contains(ap)) { |
| em.merge(ap); |
| } |
| } |
| |
| // Adding Invitor as Meetingmember |
| User user = userManager.getUserById(users_id); |
| |
| String invitorName = user.getFirstname() + " " + user.getLastname() |
| + " [" + user.getAdresses().getEmail() + "]"; |
| |
| List<MeetingMember> meetingsRemoteMembers = meetingMemberDao |
| .getMeetingMemberByAppointmentId(ap.getAppointmentId()); |
| |
| // to remove |
| for (MeetingMember memberRemote : meetingsRemoteMembers) { |
| |
| boolean found = false; |
| |
| if (mmClient != null) { |
| for (int i = 0; i < mmClient.size(); i++) { |
| |
| @SuppressWarnings("rawtypes") |
| Map clientMemeber = (Map) mmClient.get(i); |
| Long meetingMemberId = Long |
| .valueOf( |
| clientMemeber.get("meetingMemberId") |
| .toString()).longValue(); |
| |
| log.debug("DELETE newly CHECK meetingMemberId: {} VS {} -- ", meetingMemberId, memberRemote.getMeetingMemberId()); |
| |
| if (memberRemote.getMeetingMemberId().equals( |
| meetingMemberId)) { |
| log.debug("AppointMentDAOImpl.updateAppointment - member " |
| + meetingMemberId + " is to be removed!"); |
| // Notifying Member for Update |
| found = true; |
| break; |
| } |
| |
| } |
| } |
| |
| if (!found) { |
| |
| log.debug("DELETE getMeetingMemberId: {} -- ", memberRemote.getMeetingMemberId()); |
| |
| // Not in List in client delete it |
| meetingMemberLogic.deleteMeetingMember( |
| memberRemote.getMeetingMemberId(), users_id, |
| language_id); |
| // meetingMemberDao.deleteMeetingMember(memberRemote.getMeetingMemberId()); |
| } else { |
| // Notify member of changes |
| invitationManager.updateInvitation(ap, memberRemote, |
| users_id, language_id, invitorName, sendMail); |
| |
| } |
| } |
| |
| // add items |
| if (mmClient != null) { |
| |
| for (int i = 0; i < mmClient.size(); i++) { |
| |
| @SuppressWarnings("rawtypes") |
| Map clientMember = (Map) mmClient.get(i); |
| |
| Long meetingMemberId = Long.valueOf( |
| clientMember.get("meetingMemberId").toString()) |
| .longValue(); |
| |
| boolean found = false; |
| |
| for (MeetingMember memberRemote : meetingsRemoteMembers) { |
| if (memberRemote.getMeetingMemberId().equals( |
| meetingMemberId)) { |
| found = true; |
| } |
| } |
| |
| if (!found) { |
| |
| // 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); |
| timezoneMember = timezoneUtil |
| .getTimezoneByUser(interalUser); |
| omTimeZone = interalUser.getOmTimeZone(); |
| phone = interalUser.getPhoneForSMS(); |
| } 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") == null ? |
| clientMember.get("firstname").toString() : "", |
| clientMember.get("lastname") == null ? |
| clientMember.get("lastname").toString() : "", |
| "0", // member - Status |
| "0", // appointement - Status |
| appointmentId, |
| null, // UserId |
| clientMember.get("email").toString(), // Email |
| // to |
| // send |
| // to |
| phone, |
| baseUrl, // URL to send to |
| sendToUserId, // sending To: External users have |
| // a 0 here |
| new Boolean(false), // invitor |
| language_id, |
| isPasswordProtected, |
| password, |
| timezoneMember, omTimeZone, invitorName); |
| |
| } |
| |
| } |
| } |
| |
| return appointmentId; |
| } catch (Exception ex2) { |
| log.error("[updateAppointment]: ", ex2); |
| } |
| return null; |
| |
| } |
| |
| public Long updateAppointmentByTime(Long appointmentId, |
| Date appointmentstart, Date appointmentend, Long users_id, |
| String baseUrl, Long language_id, String iCalTimeZone) { |
| |
| log.debug("AppointmentDAOImpl.updateAppointment"); |
| try { |
| |
| Appointment ap = this.getAppointmentById(appointmentId); |
| |
| if (!ap.getStarttime().equals(appointmentstart) || |
| !ap.getAppointmentEndtime().equals(appointmentend)) { |
| |
| // change connected events of other participants |
| if (ap.getIsConnectedEvent() != null && ap.getIsConnectedEvent()) { |
| this.updateConnectedEventsTimeOnly(ap, appointmentstart, |
| appointmentend); |
| } |
| |
| // Update Invitation hash to new time |
| invitationManager.updateInvitationByAppointment(appointmentId, |
| appointmentstart, appointmentend); |
| |
| ap.setAppointmentStarttime(appointmentstart); |
| ap.setAppointmentEndtime(appointmentend); |
| ap.setUpdatetime(new Date()); |
| |
| if (ap.getAppointmentId() == null) { |
| em.persist(ap); |
| } else if (!em.contains(ap)) { |
| em.merge(ap); |
| } |
| |
| List<MeetingMember> meetingsRemoteMembers = meetingMemberDao |
| .getMeetingMemberByAppointmentId(ap.getAppointmentId()); |
| |
| // Adding Invitor Name |
| User user = userManager.getUserById(users_id); |
| String invitorName = user.getFirstname() + " " + user.getLastname() |
| + " [" + user.getAdresses().getEmail() + "]"; |
| |
| // Send notification of updated Event |
| for (MeetingMember memberRemote : meetingsRemoteMembers) { |
| |
| // Notify member of changes |
| invitationManager.updateInvitation(ap, memberRemote, |
| users_id, language_id, invitorName, true); |
| |
| } |
| } |
| return appointmentId; |
| } catch (Exception ex2) { |
| log.error("[updateAppointmentByTime]: ", ex2); |
| } |
| return null; |
| |
| } |
| |
| // ---------------------------------------------------------------------------------------------------------- |
| |
| public Long deleteAppointement(Long appointmentId) { |
| log.debug("deleteAppointMent"); |
| try { |
| |
| Appointment app = this.getAppointmentById(appointmentId); |
| app.setUpdatetime(new Date()); |
| app.setDeleted(true); |
| |
| if (app.getAppointmentId() == null) { |
| em.persist(app); |
| } else { |
| if (!em.contains(app)) { |
| em.merge(app); |
| } |
| } |
| return appointmentId; |
| } catch (Exception ex2) { |
| log.error("[deleteAppointement]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getAppointmentsByRange(Long userId, |
| Date starttime, Date endtime) { |
| try { |
| |
| Calendar calstart = Calendar.getInstance(); |
| calstart.setTime(starttime); |
| calstart.set(Calendar.HOUR, 0); |
| |
| Calendar calend = Calendar.getInstance(); |
| calend.setTime(endtime); |
| calend.set(Calendar.HOUR, 23); |
| calend.set(Calendar.MINUTE, 59); |
| |
| log.debug("Start " + calstart.getTime() + " End " + calend.getTime()); |
| |
| TypedQuery<Appointment> query = em.createNamedQuery("appointmentsInRange", Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("starttime", calstart.getTime()); |
| query.setParameter("endtime", calend.getTime()); |
| query.setParameter("userId", userId); |
| |
| List<Appointment> listAppoints = new ArrayList<Appointment>(query.getResultList()); |
| TypedQuery<Appointment> q1 = em.createNamedQuery("joinedAppointmentsInRange", Appointment.class); |
| q1.setParameter("starttime", calstart.getTime()); |
| q1.setParameter("endtime", calend.getTime()); |
| q1.setParameter("userId", userId); |
| for (Appointment a : q1.getResultList()) { |
| a.setIsConnectedEvent(true); //TODO need to be reviewed |
| listAppoints.add(a); |
| } |
| |
| for (Appointment appointment : listAppoints) { |
| log.debug("" + appointment); |
| |
| appointment.setMeetingMember(meetingMemberDao |
| .getMeetingMemberByAppointmentId(appointment |
| .getAppointmentId())); |
| |
| } |
| |
| return listAppoints; |
| } catch (Exception ex2) { |
| log.error("[getAppointmentsByRange]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getAppointmentsByCat(Long categoryId) { |
| try { |
| |
| String hql = "select a from Appointments a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.appointmentCategory.categoryId = :categoryId"; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("categoryId", categoryId); |
| |
| List<Appointment> listAppoints = query.getResultList(); |
| return listAppoints; |
| } catch (Exception ex2) { |
| log.error("[getAppointements]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Appointment> getAppointmentsByCritAndCat(Long cat_id) { |
| try { |
| |
| CriteriaBuilder cb = em.getCriteriaBuilder(); |
| CriteriaQuery<Appointment> cq = cb.createQuery(Appointment.class); |
| Root<Appointment> c = cq.from(Appointment.class); |
| Predicate condition = cb.equal(c.get("deleted"), false); |
| Predicate subCondition = cb.equal(c.get("categoryId"), cat_id); |
| cq.where(condition, subCondition); |
| TypedQuery<Appointment> q = em.createQuery(cq); |
| List<Appointment> listAppoints = q.getResultList(); |
| |
| return listAppoints; |
| } catch (Exception ex2) { |
| log.error("[getAppointements]: ", ex2); |
| } |
| return null; |
| } |
| |
| // next appointment to select date |
| public Appointment getNextAppointment(Date appointmentStarttime) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.appointmentStarttime > :appointmentStarttime "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("appointmentStarttime", appointmentStarttime); |
| |
| Appointment appoint = null; |
| try { |
| appoint = query.getSingleResult(); |
| } catch (NoResultException ex) { |
| } |
| |
| return appoint; |
| } catch (Exception ex2) { |
| log.error("[getNextAppointmentById]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Appointment> searchAppointmentsByName(String name) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.appointmentName LIKE :appointmentName"; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| query.setParameter("deleted", true); |
| query.setParameter("appointmentName", name); |
| |
| List<Appointment> listAppoints = query.getResultList(); |
| |
| return listAppoints; |
| } catch (Exception ex2) { |
| log.error("[searchAppointmentsByName]: ", ex2); |
| } |
| return null; |
| } |
| |
| /** |
| * @author becherer |
| * @param userId |
| * @return |
| */ |
| public List<Appointment> getTodaysAppointmentsbyRangeAndMember(Long userId) { |
| log.debug("getAppoitmentbyRangeAndMember : UserID - " + userId); |
| |
| //this query returns duplicates if the user books an appointment with |
| //his own user as second meeting-member, swagner 19.02.2012 |
| |
| String hql = "SELECT app from MeetingMember mm " |
| + "JOIN mm.appointment as app " |
| + "WHERE mm.userid.user_id= :userId " |
| + "AND mm.deleted <> :mm_deleted " |
| + "AND app.deleted <> :app_deleted " + "AND " |
| + "app.appointmentStarttime between :starttime " + "AND " |
| + " :endtime"; |
| |
| TimeZone timeZone = timezoneUtil.getTimezoneByUser(usersDao.get(userId)); |
| |
| Calendar startCal = Calendar.getInstance(timeZone); |
| startCal.set(Calendar.MINUTE, 0); |
| startCal.set(Calendar.HOUR, 0); |
| startCal.set(Calendar.SECOND, 1); |
| |
| Calendar endCal = Calendar.getInstance(timeZone); |
| endCal.set(Calendar.MINUTE, 23); |
| endCal.set(Calendar.HOUR, 59); |
| endCal.set(Calendar.SECOND, 59); |
| |
| try { |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| |
| query.setParameter("mm_deleted", true); |
| query.setParameter("app_deleted", true); |
| query.setParameter("userId", userId); |
| |
| query.setParameter("starttime", startCal.getTime()); |
| query.setParameter("endtime", endCal.getTime()); |
| |
| List<Appointment> listAppoints = query.getResultList(); |
| return listAppoints; |
| } catch (Exception e) { |
| log.error("Error in getTodaysAppoitmentsbyRangeAndMember : ", e); |
| return null; |
| } |
| } |
| |
| /** |
| * Get the meetings according to a time range. It starts by now to |
| * Calendar.getInstance().getTime().getTime() + milliseconds |
| * |
| * @author o.becherer,seba.wagner |
| * @param milliseconds |
| * to get events in the past make milliseconds < 0 |
| * @param isReminderEmailSend |
| * if null all events in the time range, if false or true the |
| * param is set |
| * @return |
| */ |
| public List<Appointment> getAppointmentsForAllUsersByTimeRangeStartingNow( |
| long milliseconds, Boolean isReminderEmailSend) { |
| try { |
| |
| String hql = "SELECT app from MeetingMember mm " |
| + "JOIN mm.appointment as app " |
| + "WHERE mm.deleted <> :mm_deleted " |
| + "AND app.deleted <> :app_deleted " |
| + "AND app.appointmentStarttime between :starttime AND :endtime "; |
| |
| if (isReminderEmailSend != null) { |
| hql += "AND ( app.isReminderEmailSend IS NULL OR app.isReminderEmailSend = :isReminderEmailSend ) "; |
| } |
| |
| Calendar startCal = Calendar.getInstance(); |
| if (milliseconds < 0) { |
| startCal.setTimeInMillis(startCal.getTimeInMillis()+milliseconds); |
| } |
| Calendar endCal = Calendar.getInstance(); |
| if (milliseconds > 0) { |
| endCal.setTimeInMillis(endCal.getTimeInMillis()+milliseconds); |
| } |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| |
| Timestamp startStamp = new Timestamp(startCal.getTime().getTime()); |
| Timestamp stopStamp = new Timestamp(endCal.getTime().getTime()); |
| |
| log.debug("startStamp "+startStamp); |
| log.debug("stopStamp "+stopStamp); |
| |
| query.setParameter("mm_deleted", true); |
| query.setParameter("app_deleted", true); |
| query.setParameter("starttime", startStamp); |
| query.setParameter("endtime", stopStamp); |
| if (isReminderEmailSend != null) { |
| query.setParameter("isReminderEmailSend", isReminderEmailSend); |
| } |
| |
| List<Appointment> listAppoints = query.getResultList(); |
| |
| return listAppoints; |
| } catch (Exception e) { |
| log.error("Error in getAppointmentsForAllUsersByTimeRangeStartingNow : ", e); |
| return null; |
| } |
| } |
| |
| // --------------------------------------------------------------------------------------------- |
| |
| public Appointment getAppointmentByRoomId(Long user_id, Long rooms_id) { |
| try { |
| |
| String hql = "select a from Appointment a " |
| + "WHERE a.deleted <> :deleted " |
| + "AND a.userId.user_id = :user_id " |
| + "AND a.room.rooms_id = :rooms_id "; |
| |
| TypedQuery<Appointment> query = em.createQuery(hql, |
| Appointment.class); |
| |
| query.setParameter("deleted", true); |
| query.setParameter("user_id", user_id); |
| query.setParameter("rooms_id", rooms_id); |
| |
| List<Appointment> listAppoints = query.getResultList(); |
| |
| if (listAppoints.size() > 0) { |
| return listAppoints.get(0); |
| } |
| |
| return null; |
| |
| } catch (Exception e) { |
| log.error("[getAppointmentByRoomId]", e); |
| return null; |
| } |
| } |
| |
| } |