Exemplo n.º 1
0
  public void setRooms() {
    int i = 0;
    Iterator iter = null;

    if (assignedRooms != null) {
      String[] assignedSelection = new String[assignedRooms.size()];
      for (iter = assignedRooms.iterator(); iter.hasNext(); ) {
        Location r = (Location) iter.next();
        assignedSelection[i] = r.getUniqueId().toString();
        i++;
      }
      assignedSelected = assignedSelection;
    }
  }
Exemplo n.º 2
0
  protected boolean dropFeature(
      Long featureId,
      Long sessionId,
      org.hibernate.Session hibSession,
      SessionContext context,
      boolean future) {
    RoomFeature rf = lookupFeature(hibSession, featureId, future, sessionId);
    if (rf == null) {
      if (!future) throw new GwtRpcException(MESSAGES.errorRoomFeatureDoesNotExist(featureId));
      return false;
    }

    if (rf instanceof GlobalRoomFeature) context.checkPermission(rf, Right.GlobalRoomFeatureDelete);
    else context.checkPermission(rf, Right.DepartmenalRoomFeatureDelete);

    ChangeLog.addChange(
        hibSession,
        context,
        rf,
        ChangeLog.Source.ROOM_FEATURE_EDIT,
        ChangeLog.Operation.DELETE,
        null,
        rf instanceof DepartmentRoomFeature ? ((DepartmentRoomFeature) rf).getDepartment() : null);

    for (Location location : rf.getRooms()) {
      location.getFeatures().remove(rf);
      hibSession.saveOrUpdate(location);
    }

    for (RoomFeaturePref p :
        (List<RoomFeaturePref>)
            hibSession
                .createQuery("from RoomFeaturePref p where p.roomFeature.uniqueId = :id")
                .setLong("id", rf.getUniqueId())
                .list()) {
      p.getOwner().getPreferences().remove(p);
      hibSession.delete(p);
      hibSession.saveOrUpdate(p.getOwner());
    }

    hibSession.delete(rf);
    return true;
  }
Exemplo n.º 3
0
 protected Collection<Location> lookupLocations(
     org.hibernate.Session hibSession, List<Long> ids, boolean future, Long sessionId) {
   if (ids == null || ids.isEmpty()) return new ArrayList<Location>();
   if (future) {
     return Location.lookupFutureLocations(hibSession, ids, sessionId);
   } else {
     return (List<Location>)
         hibSession
             .createQuery("from Location where uniqueId in :ids")
             .setParameterList("ids", ids)
             .list();
   }
 }
Exemplo n.º 4
0
 public String getFeatures(String locationId) {
   Location location = LocationDAO.getInstance().get(Long.valueOf(locationId));
   if (location == null) return "";
   String features = "";
   for (GlobalRoomFeature feature : location.getGlobalRoomFeatures()) {
     if (!features.isEmpty()) features += ", ";
     features +=
         "<span title='"
             + feature.getLabel()
             + "' style='white-space:nowrap;'>"
             + feature.getLabelWithType()
             + "</span>";
   }
   for (DepartmentRoomFeature feature : location.getDepartmentRoomFeatures()) {
     if (!features.isEmpty()) features += ", ";
     features +=
         "<span title='"
             + feature.getLabel()
             + "' style='white-space:nowrap;'>"
             + feature.getLabelWithType()
             + "</span>";
   }
   return features;
 }
Exemplo n.º 5
0
  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    boolean vertical = "1".equals(request.getParameter("v"));
    RequiredTimeTable rtt = null;
    if (request.getParameter("tp") != null) {
      TimePattern p = TimePatternDAO.getInstance().get(Long.valueOf(request.getParameter("tp")));
      if (p != null) {
        TimeLocation t = null;
        if (request.getParameter("as") != null && request.getParameter("ad") != null) {
          t =
              new TimeLocation(
                  Integer.parseInt(request.getParameter("ad")),
                  Integer.parseInt(request.getParameter("as")),
                  1,
                  0,
                  0,
                  null,
                  null,
                  null,
                  0);
        }
        rtt = new RequiredTimeTable(p.getTimePatternModel(t, true));
      }
    } else if (request.getParameter("loc") != null) {
      Location location = LocationDAO.getInstance().get(Long.valueOf(request.getParameter("loc")));
      if (location != null) {
        if (request.getParameter("xt") != null) {
          PeriodPreferenceModel px =
              new PeriodPreferenceModel(
                  location.getSession(), Long.valueOf(request.getParameter("xt")));
          px.load(location);
          rtt = new RequiredTimeTable(px);
        } else {
          if ("1".equals(request.getParameter("e"))) rtt = location.getEventAvailabilityTable();
          else rtt = location.getRoomSharingTable();
        }
      }
    } else if (request.getParameter("x") != null) {
      Exam exam = ExamDAO.getInstance().get(Long.valueOf(request.getParameter("x")));
      if (exam != null) {
        ExamPeriod p = null;
        if (request.getParameter("ap") != null)
          p = ExamPeriodDAO.getInstance().get(Long.valueOf(request.getParameter("ap")));
        PeriodPreferenceModel px =
            new PeriodPreferenceModel(exam.getSession(), p, exam.getExamType().getUniqueId());
        px.load(exam);
        rtt = new RequiredTimeTable(px);
      }
    } else {
      rtt = new RequiredTimeTable(new TimePattern().getTimePatternModel());
    }
    if (rtt != null) {
      if (request.getParameter("s") != null) {
        try {
          rtt.getModel().setDefaultSelection(Integer.parseInt(request.getParameter("s")));
        } catch (NumberFormatException e) {
          rtt.getModel().setDefaultSelection(request.getParameter("s"));
        }
      }
      if (request.getParameter("p") != null)
        rtt.getModel().setPreferences(request.getParameter("p"));
      boolean hc = ("1".equals(request.getParameter("hc")));

      response.setContentType("image/png");
      response.setHeader("Content-Disposition", "attachment; filename=\"pattern.png\"");
      BufferedImage image = rtt.createBufferedImage(vertical, hc);
      if (image != null) ImageIO.write(image, "PNG", response.getOutputStream());
    }
  }
Exemplo n.º 6
0
  @Override
  public SaveOrApproveEventRpcResponse execute(SaveEventRpcRequest request, EventContext context) {
    if (request.getEvent().hasContact()
        && (request.getEvent().getContact().getExternalId() == null
            || !request
                .getEvent()
                .getContact()
                .getExternalId()
                .equals(context.getUser().getExternalUserId()))) {
      switch (request.getEvent().getType()) {
        case Special:
        case Course:
        case Unavailabile:
          context.checkPermission(Right.EventLookupContact);
      }
    }
    if (request.getEvent().getId() == null) { // new even
      switch (request.getEvent().getType()) {
        case Special:
          context.checkPermission(Right.EventAddSpecial);
          break;
        case Course:
          context.checkPermission(Right.EventAddCourseRelated);
          break;
        case Unavailabile:
          context.checkPermission(Right.EventAddUnavailable);
          break;
        default:
          throw context.getException();
      }
    } else { // existing event
      context.checkPermission(request.getEvent().getId(), "Event", Right.EventEdit);
    }

    // Check main contact email
    if (request.getEvent().hasContact() && request.getEvent().getContact().hasEmail()) {
      try {
        new InternetAddress(request.getEvent().getContact().getEmail(), true);
      } catch (AddressException e) {
        throw new GwtRpcException(
            MESSAGES.badEmailAddress(request.getEvent().getContact().getEmail(), e.getMessage()));
      }
    }
    // Check additional emails
    if (request.getEvent().hasEmail()) {
      String suffix = ApplicationProperty.EmailDefaultAddressSuffix.value();
      for (String address : request.getEvent().getEmail().split("[\n,]")) {
        String email = address.trim();
        if (email.isEmpty()) continue;
        if (suffix != null && email.indexOf('@') < 0) email += suffix;
        try {
          new InternetAddress(email, true);
        } catch (AddressException e) {
          throw new GwtRpcException(MESSAGES.badEmailAddress(address, e.getMessage()));
        }
      }
    }

    org.hibernate.Session hibSession = SessionDAO.getInstance().getSession();
    Transaction tx = hibSession.beginTransaction();
    try {
      Session session = SessionDAO.getInstance().get(request.getSessionId(), hibSession);
      Date now = new Date();

      Event event = null;
      if (request.getEvent().getId() != null) {
        event = EventDAO.getInstance().get(request.getEvent().getId(), hibSession);
      } else {
        switch (request.getEvent().getType()) {
          case Special:
            event = new SpecialEvent();
            break;
          case Course:
            event = new CourseEvent();
            break;
          case Unavailabile:
            event = new UnavailableEvent();
            break;
          default:
            throw new GwtRpcException(
                MESSAGES.failedSaveEventWrongType(request.getEvent().getType().getName(CONSTANTS)));
        }
      }

      SaveOrApproveEventRpcResponse response = new SaveOrApproveEventRpcResponse();

      event.setEventName(request.getEvent().getName());
      if (event.getEventName() == null
          || event.getEventName().isEmpty()
              && request.getEvent().getType() == EventType.Unavailabile)
        event.setEventName(MESSAGES.unavailableEventDefaultName());
      event.setEmail(request.getEvent().getEmail());
      if (context.hasPermission(Right.EventSetExpiration) || event.getExpirationDate() != null)
        event.setExpirationDate(request.getEvent().getExpirationDate());
      event.setSponsoringOrganization(
          request.getEvent().hasSponsor()
              ? SponsoringOrganizationDAO.getInstance()
                  .get(request.getEvent().getSponsor().getUniqueId())
              : null);
      if (event instanceof UnavailableEvent) {
      } else if (event instanceof SpecialEvent) {
        event.setMinCapacity(request.getEvent().getMaxCapacity());
        event.setMaxCapacity(request.getEvent().getMaxCapacity());
      }
      if (event.getAdditionalContacts() == null) {
        event.setAdditionalContacts(new HashSet<EventContact>());
      }
      if (context.hasPermission(Right.EventLookupContact)) {
        Set<EventContact> existingContacts =
            new HashSet<EventContact>(event.getAdditionalContacts());
        event.getAdditionalContacts().clear();
        if (request.getEvent().hasAdditionalContacts())
          for (ContactInterface c : request.getEvent().getAdditionalContacts()) {
            if (c.getExternalId() == null) continue;
            EventContact contact = null;
            for (EventContact x : existingContacts)
              if (c.getExternalId().equals(x.getExternalUniqueId())) {
                contact = x;
                break;
              }
            if (contact == null) {
              contact =
                  (EventContact)
                      hibSession
                          .createQuery("from EventContact where externalUniqueId = :externalId")
                          .setString("externalId", c.getExternalId())
                          .setMaxResults(1)
                          .uniqueResult();
            }
            if (contact == null) {
              contact = new EventContact();
              contact.setExternalUniqueId(c.getExternalId());
              contact.setFirstName(c.getFirstName());
              contact.setMiddleName(c.getMiddleName());
              contact.setLastName(c.getLastName());
              contact.setAcademicTitle(c.getAcademicTitle());
              contact.setEmailAddress(c.getEmail());
              contact.setPhone(c.getPhone());
              hibSession.save(contact);
            }
            event.getAdditionalContacts().add(contact);
          }
      }

      EventContact main = event.getMainContact();
      if (main == null
          || main.getExternalUniqueId() == null
          || !main.getExternalUniqueId().equals(request.getEvent().getContact().getExternalId())) {
        main =
            (EventContact)
                hibSession
                    .createQuery("from EventContact where externalUniqueId = :externalId")
                    .setString("externalId", request.getEvent().getContact().getExternalId())
                    .setMaxResults(1)
                    .uniqueResult();
        if (main == null) {
          main = new EventContact();
          main.setExternalUniqueId(request.getEvent().getContact().getExternalId());
        }
      }
      main.setFirstName(request.getEvent().getContact().getFirstName());
      main.setMiddleName(request.getEvent().getContact().getMiddleName());
      main.setLastName(request.getEvent().getContact().getLastName());
      main.setAcademicTitle(request.getEvent().getContact().getAcademicTitle());
      main.setEmailAddress(request.getEvent().getContact().getEmail());
      main.setPhone(request.getEvent().getContact().getPhone());
      hibSession.saveOrUpdate(main);
      event.setMainContact(main);

      if (event.getNotes() == null) event.setNotes(new HashSet<EventNote>());

      if (event.getMeetings() == null) event.setMeetings(new HashSet<Meeting>());
      Set<Meeting> remove = new HashSet<Meeting>(event.getMeetings());
      TreeSet<Meeting> createdMeetings = new TreeSet<Meeting>();
      Set<Meeting> cancelledMeetings = new TreeSet<Meeting>();
      Set<Meeting> updatedMeetings = new TreeSet<Meeting>();
      for (MeetingInterface m : request.getEvent().getMeetings()) {
        Meeting meeting = null;
        if (m.getApprovalStatus() == ApprovalStatus.Deleted) {
          if (!context.hasPermission(meeting, Right.EventMeetingDelete)
              && context.hasPermission(meeting, Right.EventMeetingCancel)) {
            // Cannot delete, but can cancel --> cancel the meeting instead
            m.setApprovalStatus(ApprovalStatus.Cancelled);
          } else {
            continue;
          }
        }
        if (m.getId() != null)
          for (Iterator<Meeting> i = remove.iterator(); i.hasNext(); ) {
            Meeting x = i.next();
            if (m.getId().equals(x.getUniqueId())) {
              meeting = x;
              i.remove();
              break;
            }
          }
        if (meeting != null) {
          if (m.getApprovalStatus().ordinal() != meeting.getApprovalStatus()) {
            switch (m.getApprovalStatus()) {
              case Cancelled:
                switch (meeting.getEvent().getEventType()) {
                  case Event.sEventTypeFinalExam:
                  case Event.sEventTypeMidtermExam:
                    if (!context.hasPermission(meeting, Right.EventMeetingCancelExam))
                      throw new GwtRpcException(
                          MESSAGES.failedApproveEventNoRightsToCancel(toString(meeting)));
                    break;
                  case Event.sEventTypeClass:
                    if (!context.hasPermission(meeting, Right.EventMeetingCancelClass))
                      throw new GwtRpcException(
                          MESSAGES.failedApproveEventNoRightsToCancel(toString(meeting)));
                    break;
                  default:
                    if (!context.hasPermission(meeting, Right.EventMeetingCancel))
                      throw new GwtRpcException(
                          MESSAGES.failedApproveEventNoRightsToCancel(toString(meeting)));
                    break;
                }
                meeting.setStatus(Meeting.Status.CANCELLED);
                meeting.setApprovalDate(now);
                hibSession.update(meeting);
                cancelledMeetings.add(meeting);
                response.addCancelledMeeting(m);
            }
          } else {
            if (m.getStartOffset()
                    != (meeting.getStartOffset() == null ? 0 : meeting.getStartOffset())
                || m.getEndOffset()
                    != (meeting.getStopOffset() == null ? 0 : meeting.getStopOffset())) {
              if (!context.hasPermission(meeting, Right.EventMeetingEdit))
                throw new GwtRpcException(
                    MESSAGES.failedSaveEventCanNotEditMeeting(toString(meeting)));
              meeting.setStartOffset(m.getStartOffset());
              meeting.setStopOffset(m.getEndOffset());
              hibSession.update(meeting);
              response.addUpdatedMeeting(m);
              updatedMeetings.add(meeting);
            }
          }
        } else {
          response.addCreatedMeeting(m);
          meeting = new Meeting();
          meeting.setEvent(event);
          Location location = null;
          if (m.hasLocation()) {
            if (m.getLocation().getId() != null)
              location = LocationDAO.getInstance().get(m.getLocation().getId(), hibSession);
            else if (m.getLocation().getName() != null)
              location =
                  Location.findByName(
                      hibSession, request.getSessionId(), m.getLocation().getName());
          }
          if (location == null)
            throw new GwtRpcException(MESSAGES.failedSaveEventNoLocation(toString(m)));
          meeting.setLocationPermanentId(location.getPermanentId());
          meeting.setStatus(Meeting.Status.PENDING);
          meeting.setApprovalDate(null);
          if (!context.hasPermission(location, Right.EventLocation))
            throw new GwtRpcException(MESSAGES.failedSaveEventWrongLocation(m.getLocationName()));
          if (request.getEvent().getType() == EventType.Unavailabile
              && !context.hasPermission(location, Right.EventLocationUnavailable))
            throw new GwtRpcException(
                MESSAGES.failedSaveCannotMakeUnavailable(m.getLocationName()));
          if (m.getApprovalStatus() == ApprovalStatus.Approved
              && context.hasPermission(location, Right.EventLocationApprove)) {
            meeting.setStatus(Meeting.Status.APPROVED);
            meeting.setApprovalDate(now);
          }
          if (context.isPastOrOutside(m.getMeetingDate()))
            throw new GwtRpcException(
                MESSAGES.failedSaveEventPastOrOutside(getDateFormat().format(m.getMeetingDate())));
          if (!context.hasPermission(location, Right.EventLocationOverbook)) {
            List<MeetingConflictInterface> conflicts =
                computeConflicts(hibSession, m, event.getUniqueId());
            if (!conflicts.isEmpty())
              throw new GwtRpcException(
                  MESSAGES.failedSaveEventConflict(toString(m), toString(conflicts.get(0))));
          }
          m.setApprovalDate(meeting.getApprovalDate());
          m.setApprovalStatus(meeting.getApprovalStatus());
          meeting.setStartPeriod(m.getStartSlot());
          meeting.setStopPeriod(m.getEndSlot());
          meeting.setStartOffset(m.getStartOffset());
          meeting.setStopOffset(m.getEndOffset());
          meeting.setClassCanOverride(true);
          meeting.setMeetingDate(m.getMeetingDate());
          event.getMeetings().add(meeting);
          createdMeetings.add(meeting);
        }
        // automatic approval
        if (meeting.getApprovalDate() == null) {
          switch (request.getEvent().getType()) {
            case Unavailabile:
            case Class:
            case FinalExam:
            case MidtermExam:
              meeting.setStatus(Meeting.Status.APPROVED);
              meeting.setApprovalDate(now);
              break;
          }
        }
      }

      if (!remove.isEmpty()) {
        for (Iterator<Meeting> i = remove.iterator(); i.hasNext(); ) {
          Meeting m = i.next();
          if (!context.hasPermission(m, Right.EventMeetingDelete)) {
            if (m.getStatus() == Status.CANCELLED || m.getStatus() == Status.REJECTED) {
              i.remove();
              continue;
            }
            throw new GwtRpcException(MESSAGES.failedSaveEventCanNotDeleteMeeting(toString(m)));
          }
          MeetingInterface meeting = new MeetingInterface();
          meeting.setId(m.getUniqueId());
          meeting.setMeetingDate(m.getMeetingDate());
          meeting.setDayOfWeek(Constants.getDayOfWeek(m.getMeetingDate()));
          meeting.setStartTime(m.getStartTime().getTime());
          meeting.setStopTime(m.getStopTime().getTime());
          meeting.setDayOfYear(
              CalendarUtils.date2dayOfYear(session.getSessionStartYear(), m.getMeetingDate()));
          meeting.setStartSlot(m.getStartPeriod());
          meeting.setEndSlot(m.getStopPeriod());
          meeting.setStartOffset(m.getStartOffset() == null ? 0 : m.getStartOffset());
          meeting.setEndOffset(m.getStopOffset() == null ? 0 : m.getStopOffset());
          meeting.setPast(context.isPastOrOutside(m.getStartTime()));
          meeting.setApprovalDate(m.getApprovalDate());
          meeting.setApprovalStatus(m.getApprovalStatus());
          if (m.getLocation() != null) {
            ResourceInterface location = new ResourceInterface();
            location.setType(ResourceType.ROOM);
            location.setId(m.getLocation().getUniqueId());
            location.setName(m.getLocation().getLabel());
            location.setSize(m.getLocation().getCapacity());
            location.setRoomType(m.getLocation().getRoomTypeLabel());
            location.setBreakTime(m.getLocation().getEffectiveBreakTime());
            location.setMessage(m.getLocation().getEventMessage());
            location.setIgnoreRoomCheck(m.getLocation().isIgnoreRoomCheck());
            meeting.setLocation(location);
          }
          response.addDeletedMeeting(meeting);
        }
        event.getMeetings().removeAll(remove);
      }

      EventInterface.DateFormatter df =
          new EventInterface.DateFormatter() {
            Formats.Format<Date> dfShort = Formats.getDateFormat(Formats.Pattern.DATE_EVENT_SHORT);
            Formats.Format<Date> dfLong = Formats.getDateFormat(Formats.Pattern.DATE_EVENT_LONG);

            @Override
            public String formatFirstDate(Date date) {
              return dfShort.format(date);
            }

            @Override
            public String formatLastDate(Date date) {
              return dfLong.format(date);
            }
          };

      FileItem attachment = (FileItem) context.getAttribute(UploadServlet.SESSION_LAST_FILE);
      boolean attached = false;
      if (response.hasCreatedMeetings()) {
        EventNote note = new EventNote();
        note.setEvent(event);
        note.setNoteType(
            event.getUniqueId() == null
                ? EventNote.sEventNoteTypeCreateEvent
                : EventNote.sEventNoteTypeAddMeetings);
        note.setTimeStamp(now);
        note.setUser(context.getUser().getTrueName());
        note.setUserId(context.getUser().getTrueExternalUserId());
        if (request.hasMessage()) note.setTextNote(request.getMessage());
        note.setMeetings(
            EventInterface.toString(response.getCreatedMeetings(), CONSTANTS, "\n", df));
        note.setAffectedMeetings(createdMeetings);
        event.getNotes().add(note);
        NoteInterface n = new NoteInterface();
        n.setDate(now);
        n.setMeetings(note.getMeetings());
        n.setUser(context.getUser().getTrueName());
        n.setType(NoteInterface.NoteType.values()[note.getNoteType()]);
        n.setNote(note.getTextNote());
        if (attachment != null) {
          note.setAttachedName(attachment.getName());
          note.setAttachedFile(attachment.get());
          note.setAttachedContentType(attachment.getContentType());
          attached = true;
          n.setAttachment(attachment.getName());
        }
        response.addNote(n);
      }
      if (response.hasUpdatedMeetings()
          || (!response.hasCreatedMeetings()
              && !response.hasDeletedMeetings()
              && !response.hasCancelledMeetings())) {
        EventNote note = new EventNote();
        note.setEvent(event);
        note.setNoteType(EventNote.sEventNoteTypeEditEvent);
        note.setTimeStamp(now);
        note.setUser(context.getUser().getTrueName());
        note.setUserId(context.getUser().getTrueExternalUserId());
        note.setAffectedMeetings(updatedMeetings);
        if (request.hasMessage()) note.setTextNote(request.getMessage());
        if (response.hasUpdatedMeetings())
          note.setMeetings(
              EventInterface.toString(response.getUpdatedMeetings(), CONSTANTS, "\n", df));
        event.getNotes().add(note);
        NoteInterface n = new NoteInterface();
        n.setDate(now);
        n.setMeetings(note.getMeetings());
        n.setUser(context.getUser().getTrueName());
        n.setType(NoteInterface.NoteType.values()[note.getNoteType()]);
        n.setNote(note.getTextNote());
        if (attachment != null && !attached) {
          note.setAttachedName(attachment.getName());
          note.setAttachedFile(attachment.get());
          note.setAttachedContentType(attachment.getContentType());
          attached = true;
          n.setAttachment(attachment.getName());
        }
        response.addNote(n);
      }
      if (response.hasDeletedMeetings()) {
        EventNote note = new EventNote();
        note.setEvent(event);
        note.setNoteType(EventNote.sEventNoteTypeDeletion);
        note.setTimeStamp(now);
        note.setUser(context.getUser().getTrueName());
        note.setUserId(context.getUser().getTrueExternalUserId());
        if (request.hasMessage()) note.setTextNote(request.getMessage());
        note.setMeetings(
            EventInterface.toString(response.getDeletedMeetings(), CONSTANTS, "\n", df));
        event.getNotes().add(note);
        NoteInterface n = new NoteInterface();
        n.setDate(now);
        n.setMeetings(note.getMeetings());
        n.setUser(context.getUser().getTrueName());
        n.setType(NoteInterface.NoteType.values()[note.getNoteType()]);
        n.setNote(note.getTextNote());
        if (attachment != null && !attached) {
          note.setAttachedName(attachment.getName());
          note.setAttachedFile(attachment.get());
          note.setAttachedContentType(attachment.getContentType());
          attached = true;
          n.setAttachment(attachment.getName());
        }
        response.addNote(n);
      }
      if (response.hasCancelledMeetings()) {
        EventNote note = new EventNote();
        note.setEvent(event);
        note.setNoteType(EventNote.sEventNoteTypeCancel);
        note.setTimeStamp(now);
        note.setUser(context.getUser().getTrueName());
        note.setUserId(context.getUser().getTrueExternalUserId());
        note.setAffectedMeetings(cancelledMeetings);
        if (request.hasMessage()) note.setTextNote(request.getMessage());
        note.setMeetings(
            EventInterface.toString(response.getCancelledMeetings(), CONSTANTS, "\n", df));
        event.getNotes().add(note);
        NoteInterface n = new NoteInterface();
        n.setDate(now);
        n.setMeetings(note.getMeetings());
        n.setUser(context.getUser().getTrueName());
        n.setType(NoteInterface.NoteType.values()[note.getNoteType()]);
        n.setNote(note.getTextNote());
        if (attachment != null && !attached) {
          note.setAttachedName(attachment.getName());
          note.setAttachedFile(attachment.get());
          note.setAttachedContentType(attachment.getContentType());
          attached = true;
          n.setAttachment(attachment.getName());
        }
        response.addNote(n);
      }

      if (request.getEvent().getType() == EventType.Course) {
        CourseEvent ce = (CourseEvent) event;
        ce.setReqAttendance(request.getEvent().hasRequiredAttendance());
        if (ce.getRelatedCourses() == null) ce.setRelatedCourses(new HashSet<RelatedCourseInfo>());
        else ce.getRelatedCourses().clear();
        if (request.getEvent().hasRelatedObjects())
          for (RelatedObjectInterface r : request.getEvent().getRelatedObjects()) {
            RelatedCourseInfo related = new RelatedCourseInfo();
            related.setEvent(ce);
            if (r.getSelection() != null) {
              related.setOwnerId(r.getUniqueId());
              related.setOwnerType(r.getType().ordinal());
              related.setCourse(
                  CourseOfferingDAO.getInstance().get(r.getSelection()[1], hibSession));
            } else {
              switch (r.getType()) {
                case Course:
                  related.setOwner(CourseOfferingDAO.getInstance().get(r.getUniqueId()));
                  break;
                case Class:
                  related.setOwner(Class_DAO.getInstance().get(r.getUniqueId()));
                  break;
                case Config:
                  related.setOwner(InstrOfferingConfigDAO.getInstance().get(r.getUniqueId()));
                  break;
                case Offering:
                  related.setOwner(InstructionalOfferingDAO.getInstance().get(r.getUniqueId()));
                  break;
              }
            }
            ce.getRelatedCourses().add(related);
          }
      }

      if (event.getUniqueId() == null) {
        hibSession.save(event);
        response.setEvent(
            EventDetailBackend.getEventDetail(
                SessionDAO.getInstance().get(request.getSessionId(), hibSession), event, context));
      } else if (event.getMeetings().isEmpty()) {
        response.setEvent(
            EventDetailBackend.getEventDetail(
                SessionDAO.getInstance().get(request.getSessionId(), hibSession), event, context));
        response.getEvent().setId(null);
        hibSession.delete(event);
      } else {
        hibSession.update(event);
        response.setEvent(
            EventDetailBackend.getEventDetail(
                SessionDAO.getInstance().get(request.getSessionId(), hibSession), event, context));
      }

      tx.commit();

      new EventEmail(request, response).send(context);

      return response;
    } catch (Exception ex) {
      tx.rollback();
      if (ex instanceof GwtRpcException) throw (GwtRpcException) ex;
      throw new GwtRpcException(ex.getMessage(), ex);
    }
  }
Exemplo n.º 7
0
  protected RoomFeature createOrUpdateFeature(
      FeatureInterface feature,
      List<Long> add,
      List<Long> drop,
      Long sessionId,
      org.hibernate.Session hibSession,
      SessionContext context,
      boolean future) {
    Department d =
        feature.isDepartmental()
            ? lookuDepartment(hibSession, feature.getDepartment(), future, sessionId)
            : null;
    if (feature.isDepartmental() && d == null) return null;

    RoomFeature rf =
        (feature.getId() == null ? null : lookupFeature(hibSession, feature, future, sessionId));

    if (rf == null) {
      if (!future && feature.getId() != null)
        throw new GwtRpcException(MESSAGES.errorRoomFeatureDoesNotExist(feature.getId()));
      if (d == null) {
        context.checkPermission(Right.GlobalRoomFeatureAdd);
        rf = new GlobalRoomFeature();
        ((GlobalRoomFeature) rf).setSession(SessionDAO.getInstance().get(sessionId));
      } else {
        context.checkPermission(d, Right.DepartmentRoomFeatureAdd);
        rf = new DepartmentRoomFeature();
        ((DepartmentRoomFeature) rf).setDepartment(d);
      }
      rf.setRooms(new HashSet<Location>());
    } else {
      if (rf instanceof GlobalRoomFeature) {
        context.checkPermission(rf, Right.GlobalRoomFeatureEdit);
      } else {
        context.checkPermission(rf, Right.DepartmenalRoomFeatureEdit);
        ((DepartmentRoomFeature) rf).setDepartment(d);
      }
    }

    for (Iterator i = RoomFeature.getAllGlobalRoomFeatures(sessionId).iterator(); i.hasNext(); ) {
      RoomFeature x = (RoomFeature) i.next();
      if ((x.getLabel().equalsIgnoreCase(feature.getLabel())
              || x.getAbbv().equalsIgnoreCase(feature.getAbbreviation()))
          && !x.getUniqueId().equals(rf.getUniqueId()))
        throw new GwtRpcException(
            MESSAGES.errorRoomFeatureAlreadyExists(
                feature.getLabel(), SessionDAO.getInstance().get(sessionId).getLabel()));
    }

    if (rf instanceof DepartmentRoomFeature) {
      for (Iterator i = RoomFeature.getAllDepartmentRoomFeatures(d).iterator(); i.hasNext(); ) {
        RoomFeature x = (RoomFeature) i.next();
        if ((x.getLabel().equalsIgnoreCase(feature.getLabel())
                || x.getAbbv().equalsIgnoreCase(feature.getAbbreviation()))
            && !x.getUniqueId().equals(rf.getUniqueId()))
          throw new GwtRpcException(
              MESSAGES.errorRoomFeatureAlreadyExists(
                  feature.getLabel(), d.getSession().getLabel()));
      }
    }

    rf.setAbbv(feature.getAbbreviation());
    rf.setLabel(feature.getLabel());
    rf.setFeatureType(
        feature.getType() == null
            ? null
            : RoomFeatureTypeDAO.getInstance().get(feature.getType().getId(), hibSession));

    hibSession.saveOrUpdate(rf);

    if (add != null && !add.isEmpty())
      for (Location location : lookupLocations(hibSession, add, future, sessionId)) {
        rf.getRooms().add(location);
        location.getFeatures().add(rf);
        hibSession.saveOrUpdate(location);
      }

    if (drop != null && !drop.isEmpty())
      for (Location location : lookupLocations(hibSession, drop, future, sessionId)) {
        rf.getRooms().remove(location);
        location.getFeatures().remove(rf);
        hibSession.saveOrUpdate(location);
      }

    hibSession.saveOrUpdate(rf);

    ChangeLog.addChange(
        hibSession,
        context,
        rf,
        ChangeLog.Source.ROOM_FEATURE_EDIT,
        (feature.getId() == null ? ChangeLog.Operation.CREATE : ChangeLog.Operation.UPDATE),
        null,
        rf instanceof DepartmentRoomFeature ? ((DepartmentRoomFeature) rf).getDepartment() : null);

    return rf;
  }
Exemplo n.º 8
0
  public void loadXml(Element root) throws Exception {
    if (!root.getName().equalsIgnoreCase("roomSharing")) {
      throw new Exception("Given XML file is not a Room Sharing load file.");
    }
    try {
      beginTransaction();

      String campus = root.attributeValue("campus");
      String year = root.attributeValue("year");
      String term = root.attributeValue("term");
      iTimeFormat = root.attributeValue("timeFormat");
      if (iTimeFormat == null) iTimeFormat = "HHmm";

      Session session = Session.getSessionUsingInitiativeYearTerm(campus, year, term);
      if (session == null) {
        throw new Exception("No session found for the given campus, year, and term.");
      }

      if (!"true".equals(root.attributeValue("force"))
          && Solution.hasTimetable(session.getUniqueId())) {
        info(
            "Note: set the attribute force='true' of the root element to override the following import eligibility check.");
        throw new Exception(
            "Room sharing import is disabled: "
                + session.getLabel()
                + " already has a committed timetable.");
      }

      info("Loading rooms...");
      Set<String> avoidRoomId = new HashSet<String>();
      Set<String> avoidRoomName = new HashSet<String>();
      Map<String, Location> id2location = new HashMap<String, Location>();
      Map<String, Location> name2location = new HashMap<String, Location>();
      for (Location location :
          (List<Location>)
              getHibSession()
                  .createQuery("from Location where session.uniqueId = :sessionId")
                  .setLong("sessionId", session.getUniqueId())
                  .list()) {
        if (location.getExternalUniqueId() != null && !avoidRoomId.contains(avoidRoomId)) {
          Location old = id2location.put(location.getExternalUniqueId(), location);
          if (old != null) {
            warn(
                "There are two or more rooms with the same external id "
                    + location.getExternalUniqueId()
                    + ": "
                    + location.getLabel()
                    + " and "
                    + old.getLabel()
                    + ".");
            avoidRoomId.add(location.getExternalUniqueId());
          }
        }
        if (!avoidRoomName.contains(location.getLabel())) {
          Location old = name2location.put(location.getLabel(), location);
          if (old != null) {
            warn("There are two or more rooms with the same name " + location.getLabel() + ".");
            avoidRoomName.add(location.getLabel());
          }
        }
      }

      info("Loading departments...");
      Map<String, Department> id2department = new HashMap<String, Department>();
      Map<String, Department> code2department = new HashMap<String, Department>();
      for (Department dept :
          (List<Department>)
              getHibSession()
                  .createQuery("from Department where session.uniqueId = :sessionId")
                  .setLong("sessionId", session.getUniqueId())
                  .list()) {
        if (dept.getExternalUniqueId() != null) {
          Department old = id2department.put(dept.getExternalUniqueId(), dept);
          if (old != null) {
            warn(
                "There are two departments with the same external id "
                    + dept.getExternalUniqueId()
                    + ": "
                    + dept.getLabel()
                    + " and "
                    + old.getLabel()
                    + ".");
          }
        }
        Department old = code2department.put(dept.getDeptCode(), dept);
        if (old != null) {
          warn(
              "There are two rooms with the same code "
                  + dept.getDeptCode()
                  + ": "
                  + dept.getName()
                  + " and "
                  + old.getName()
                  + ".");
        }
      }

      info("Importing room sharing...");
      int nrChanged = 0;
      for (Iterator i = root.elementIterator("location"); i.hasNext(); ) {
        Element locEl = (Element) i.next();
        Location location = null;

        String locId = locEl.attributeValue("id");
        if (locId != null && !avoidRoomId.contains(locId)) {
          location = id2location.get(locId);
          if (location == null) warn("Location of id " + locId + " does not exist.");
        }

        if (location == null) {
          String building = locEl.attributeValue("building");
          String roomNbr = locEl.attributeValue("roomNbr");
          if (building != null
              && roomNbr != null
              && !avoidRoomName.contains(building + " " + roomNbr)) {
            location = name2location.get(building + " " + roomNbr);
            if (location == null)
              warn(
                  "Location of building "
                      + building
                      + " and room number "
                      + roomNbr
                      + " does not exist.");
          }
        }

        if (location == null) {
          String name = locEl.attributeValue("name");
          if (name != null && !avoidRoomName.contains(name)) {
            location = name2location.get(name);
            if (location == null) warn("Location of name " + name + " does not exist.");
          }
        }

        if (location == null) continue;

        Set<RoomDept> existing = new HashSet<RoomDept>(location.getRoomDepts());
        Set<Department> departments = new HashSet<Department>();
        boolean changed = false;

        String note = locEl.attributeValue("note");
        if (note == null && location.getShareNote() != null) {
          location.setShareNote(null);
          info(location.getLabel() + ": share note removed.");
          changed = true;
        } else if (note != null && !note.equals(location.getShareNote())) {
          location.setShareNote(note);
          info(location.getLabel() + ": share note changed to '" + note + "'.");
          changed = true;
        }

        department:
        for (Iterator j = locEl.elementIterator("department"); j.hasNext(); ) {
          Element deptEl = (Element) j.next();
          Department dept = null;

          String deptId = deptEl.attributeValue("id");
          if (deptId != null) {
            dept = id2department.get(deptId);
            if (dept == null)
              warn(location.getLabel() + ": Department of id " + deptId + " does not exist.");
          }

          String deptCode = deptEl.attributeValue("code");
          if (deptCode != null) {
            dept = code2department.get(deptCode);
            if (dept == null)
              warn(location.getLabel() + ": Department of code " + deptCode + " does not exist.");
          }

          if (dept == null) continue;
          Boolean control = "true".equals(deptEl.attributeValue("control"));

          for (Iterator<RoomDept> k = existing.iterator(); k.hasNext(); ) {
            RoomDept rd = k.next();
            if (rd.getDepartment().equals(dept)) {
              if (!control.equals(rd.getControl())) {
                rd.setControl(control);
                getHibSession().update(rd);
                info(
                    location.getLabel()
                        + ": "
                        + (control
                            ? " control moved to " + dept.getLabel()
                            : " control removed from " + dept.getLabel()));
                changed = true;
              }
              k.remove();
              departments.add(dept);
              continue department;
            }
          }

          RoomDept rd = new RoomDept();
          rd.setControl(control);
          rd.setDepartment(dept);
          rd.setRoom(location);
          location.getRoomDepts().add(rd);
          dept.getRoomDepts().add(rd);
          getHibSession().save(rd);
          departments.add(dept);
          info(
              location.getLabel()
                  + ": added "
                  + (control ? "controlling " : "")
                  + " department"
                  + dept.getLabel());
          changed = true;
        }

        for (RoomDept rd : existing) {
          info(
              location.getLabel()
                  + ": removed "
                  + (rd.isControl() ? "controlling " : "")
                  + " department"
                  + rd.getDepartment().getLabel());
          location.getRoomDepts().remove(rd);
          rd.getDepartment().getRoomDepts().remove(rd);
          getHibSession().delete(rd);
          changed = true;
        }

        RoomSharingModel model = location.getRoomSharingModel();
        String oldModel = model.toString();
        model.setPreferences(null);

        Element sharingEl = locEl.element("sharing");
        if (sharingEl != null) {
          for (Iterator j = sharingEl.elementIterator(); j.hasNext(); ) {
            Element el = (Element) j.next();
            TimeObject time =
                new TimeObject(
                    el.attributeValue("start"),
                    el.attributeValue("end"),
                    el.attributeValue("days"));

            String pref = null;
            if ("unavailable".equals(el.getName())) {
              pref = RoomSharingModel.sNotAvailablePref.toString();
            } else if ("assigned".equals(el.getName())) {
              Department dept = null;

              String deptId = el.attributeValue("id");
              if (deptId != null) {
                dept = id2department.get(deptId);
                if (dept == null)
                  warn(location.getLabel() + ": Department of id " + deptId + " does not exist.");
              }

              String deptCode = el.attributeValue("code");
              if (deptCode != null) {
                dept = code2department.get(deptCode);
                if (dept == null)
                  warn(
                      location.getLabel()
                          + ": Department of code "
                          + deptCode
                          + " does not exist.");
              }

              if (dept == null) continue;
              if (!departments.contains(dept)) {
                warn(
                    location.getLabel()
                        + ": Department "
                        + dept.getLabel()
                        + " is not among the room sharing departments.");
                continue;
              }

              pref = dept.getUniqueId().toString();
            }

            if (pref == null) continue;

            if (time.hasDays()) {
              for (int d : time.getDays())
                for (int t = time.getStartPeriod(); t < time.getEndPeriod(); t++)
                  model.setPreference(d, t, pref);
            } else {
              for (int d = 0; d < model.getNrDays(); d++)
                for (int t = time.getStartPeriod(); t < time.getEndPeriod(); t++)
                  model.setPreference(d, t, pref);
            }
          }
        }

        String newModel = model.toString();
        if (!oldModel.equals(newModel)) {
          info(
              location.getLabel()
                  + ": room sharing changed to "
                  + (newModel.isEmpty() ? "free for all" : newModel));
          changed = true;
        }

        location.setRoomSharingModel(model);
        getHibSession().update(location);

        if (changed) nrChanged++;
      }

      if (nrChanged == 0) {
        info("No change detected.");
      } else {
        info(nrChanged + " locations have changed.");
      }
      info("All done.");

      commitTransaction();
    } catch (Exception e) {
      fatal("Exception: " + e.getMessage(), e);
      rollbackTransaction();
      throw e;
    }
  }