Ejemplo n.º 1
1
 public static boolean isAllDayEvent(CalendarEvent eventCalendar) {
   Calendar cal1 = getInstanceOfCurrentCalendar();
   Calendar cal2 = getInstanceOfCurrentCalendar();
   cal1.setTime(eventCalendar.getFromDateTime());
   cal2.setTime(eventCalendar.getToDateTime());
   return (cal1.get(Calendar.HOUR_OF_DAY) == 0
       && cal1.get(Calendar.MINUTE) == 0
       && cal2.get(Calendar.HOUR_OF_DAY) == cal2.getActualMaximum(Calendar.HOUR_OF_DAY)
       && cal2.get(Calendar.MINUTE) == cal2.getActualMaximum(Calendar.MINUTE));
 }
 private Map<String, String> makeActivityParams(
     CalendarEvent event, String calendarId, String eventType) {
   Map<String, String> params = new HashMap<String, String>();
   params.put(EVENT_TYPE_KEY, eventType);
   params.put(EVENT_ID_KEY, event.getId());
   params.put(CALENDAR_ID_KEY, calendarId);
   params.put(EVENT_SUMMARY_KEY, event.getSummary());
   params.put(EVENT_LOCALE_KEY, event.getLocation() != null ? event.getLocation() : "");
   params.put(EVENT_DESCRIPTION_KEY, event.getDescription() != null ? event.getDescription() : "");
   params.put(EVENT_STARTTIME_KEY, String.valueOf(event.getFromDateTime().getTime()));
   params.put(EVENT_ENDTIME_KEY, String.valueOf(event.getToDateTime().getTime()));
   params.put(EVENT_LINK_KEY, makeEventLink(event));
   return params;
 }
 private boolean isAllDayEvent(CalendarEvent eventCalendar) {
   try {
     TimeZone tz = getUserTimeZone();
     Calendar cal1 = new GregorianCalendar(tz);
     Calendar cal2 = new GregorianCalendar(tz);
     cal1.setLenient(false);
     cal1.setTime(eventCalendar.getFromDateTime());
     // cal1.setTimeZone(tz);
     cal2.setLenient(false);
     cal2.setTime(eventCalendar.getToDateTime());
     // cal2.setTimeZone(tz);
     return (cal1.get(Calendar.HOUR_OF_DAY) == 0
         && cal1.get(Calendar.MINUTE) == 0
         && cal2.get(Calendar.HOUR_OF_DAY) == cal2.getActualMaximum(Calendar.HOUR_OF_DAY)
         && cal2.get(Calendar.MINUTE) == cal2.getActualMaximum(Calendar.MINUTE));
   } catch (Exception e) {
     if (LOG.isDebugEnabled()) LOG.error("Can not check all day event when event updated ", e);
   }
   return false;
 }
Ejemplo n.º 4
0
 @Override
 public void execute(Event<UIWeekView> event) throws Exception {
   UIWeekView calendarview = event.getSource();
   String eventId = event.getRequestContext().getRequestParameter(OBJECTID);
   String calendarId = event.getRequestContext().getRequestParameter(eventId + CALENDARID);
   String calType = event.getRequestContext().getRequestParameter(eventId + CALTYPE);
   String startTime = event.getRequestContext().getRequestParameter(eventId + START_TIME);
   String finishTime = event.getRequestContext().getRequestParameter(eventId + FINISH_TIME);
   Boolean isOccur = false;
   if (!Utils.isEmpty(event.getRequestContext().getRequestParameter(eventId + ISOCCUR))) {
     isOccur =
         Boolean.parseBoolean(event.getRequestContext().getRequestParameter(eventId + ISOCCUR));
   }
   String recurId = null;
   if (isOccur) recurId = event.getRequestContext().getRequestParameter(eventId + RECURID);
   try {
     String username = CalendarUtils.getCurrentUser();
     CalendarEvent eventCalendar = null;
     if (isOccur && !Utils.isEmpty(recurId)) {
       eventCalendar = calendarview.getRecurrenceMap().get(eventId).get(recurId);
     } else {
       eventCalendar = calendarview.getDataMap().get(eventId);
     }
     if (eventCalendar != null) {
       CalendarService calendarService = CalendarUtils.getCalendarService();
       Calendar calBegin = calendarview.getInstanceTempCalendar();
       Calendar calEnd = calendarview.getInstanceTempCalendar();
       long unit = 15 * 60 * 1000;
       calBegin.setTimeInMillis((Long.parseLong(startTime) / unit) * unit);
       eventCalendar.setFromDateTime(calBegin.getTime());
       calEnd.setTimeInMillis((Long.parseLong(finishTime) / unit) * unit);
       eventCalendar.setToDateTime(calEnd.getTime());
       if (eventCalendar.getToDateTime().before(eventCalendar.getFromDateTime())) {
         return;
       }
       org.exoplatform.calendar.service.Calendar calendar = null;
       if (CalendarUtils.PRIVATE_TYPE.equals(calType)) {
         calendar = calendarService.getUserCalendar(username, calendarId);
       } else if (CalendarUtils.SHARED_TYPE.equals(calType)) {
         if (calendarService.getSharedCalendars(username, true) != null)
           calendar =
               calendarService.getSharedCalendars(username, true).getCalendarById(calendarId);
       } else if (CalendarUtils.PUBLIC_TYPE.equals(calType)) {
         calendar = calendarService.getGroupCalendar(calendarId);
       }
       if (calendar == null) {
         event
             .getRequestContext()
             .getUIApplication()
             .addMessage(new ApplicationMessage("UICalendars.msg.have-no-calendar", null, 1));
       } else {
         if ((CalendarUtils.SHARED_TYPE.equals(calType)
                 && !CalendarUtils.canEdit(
                     calendarview.getApplicationComponent(OrganizationService.class),
                     Utils.getEditPerUsers(calendar),
                     username))
             || (CalendarUtils.PUBLIC_TYPE.equals(calType)
                 && !CalendarUtils.canEdit(
                     calendarview.getApplicationComponent(OrganizationService.class),
                     calendar.getEditPermission(),
                     username))) {
           event
               .getRequestContext()
               .getUIApplication()
               .addMessage(
                   new ApplicationMessage(
                       "UICalendars.msg.have-no-permission-to-edit-event", null, 1));
           calendarview.refresh();
           event.getRequestContext().addUIComponentToUpdateByAjax(calendarview.getParent());
           return;
         }
         // if it's a 'virtual' occurrence
         if (isOccur && !Utils.isEmpty(recurId)) {
           List<CalendarEvent> listEvent = new ArrayList<CalendarEvent>();
           listEvent.add(eventCalendar);
           calendarService.updateOccurrenceEvent(
               calendarId, calendarId, calType, calType, listEvent, username);
         } else {
           if (calType.equals(CalendarUtils.PRIVATE_TYPE)) {
             calendarService.saveUserEvent(username, calendarId, eventCalendar, false);
           } else if (calType.equals(CalendarUtils.SHARED_TYPE)) {
             calendarService.saveEventToSharedCalendar(
                 username, calendarId, eventCalendar, false);
           } else if (calType.equals(CalendarUtils.PUBLIC_TYPE)) {
             calendarService.savePublicEvent(calendarId, eventCalendar, false);
           }
         }
         calendarview.setLastUpdatedEventId(eventId);
         calendarview.refresh();
         UIMiniCalendar uiMiniCalendar =
             calendarview
                 .getAncestorOfType(UICalendarPortlet.class)
                 .findFirstComponentOfType(UIMiniCalendar.class);
         event.getRequestContext().addUIComponentToUpdateByAjax(uiMiniCalendar);
         event.getRequestContext().addUIComponentToUpdateByAjax(calendarview.getParent());
       }
     }
   } catch (Exception e) {
     if (log.isDebugEnabled()) {
       log.debug("Fail to save the event to the calendar", e);
     }
     return;
   }
 }
Ejemplo n.º 5
0
    @Override
    public void execute(Event<UIWeekView> event) throws Exception {

      UIWeekView calendarview = event.getSource();
      UICalendarPortlet uiCalendarPortlet = calendarview.getAncestorOfType(UICalendarPortlet.class);
      String eventId = event.getRequestContext().getRequestParameter(OBJECTID);
      String calendarId = event.getRequestContext().getRequestParameter(eventId + CALENDARID);
      String calType = event.getRequestContext().getRequestParameter(eventId + CALTYPE);
      String startTime = event.getRequestContext().getRequestParameter(eventId + START_TIME);
      String finishTime = event.getRequestContext().getRequestParameter(eventId + FINISH_TIME);
      String currentDate = event.getRequestContext().getRequestParameter(eventId + CURRENT_DATE);

      Boolean isOccur = false;
      if (!Utils.isEmpty(event.getRequestContext().getRequestParameter(eventId + ISOCCUR))) {
        isOccur =
            Boolean.parseBoolean(event.getRequestContext().getRequestParameter(eventId + ISOCCUR));
      }
      String recurId = null;
      if (isOccur) recurId = event.getRequestContext().getRequestParameter(eventId + RECURID);

      String username = CalendarUtils.getCurrentUser();
      CalendarService calendarService = CalendarUtils.getCalendarService();

      CalendarEvent eventCalendar = calendarview.getDataMap().get(eventId);
      if (isOccur && !Utils.isEmpty(recurId)) {
        eventCalendar = calendarview.getRecurrenceMap().get(eventId).get(recurId);
      }

      if (eventCalendar != null) {
        CalendarService calService = CalendarUtils.getCalendarService();
        boolean isMove = false;
        try {
          org.exoplatform.calendar.service.Calendar calendar = null;
          if (eventCalendar.getCalType().equals(CalendarUtils.PRIVATE_TYPE)) {
            calendar = calService.getUserCalendar(username, calendarId);
          } else if (eventCalendar.getCalType().equals(CalendarUtils.SHARED_TYPE)) {
            if (calService.getSharedCalendars(username, true) != null)
              calendar = calService.getSharedCalendars(username, true).getCalendarById(calendarId);
          } else if (eventCalendar.getCalType().equals(CalendarUtils.PUBLIC_TYPE)) {
            calendar = calService.getGroupCalendar(calendarId);
          }
          if (calendar == null) {
            event
                .getRequestContext()
                .getUIApplication()
                .addMessage(new ApplicationMessage("UICalendars.msg.have-no-calendar", null, 1));
          } else {
            Calendar cal = calendarview.getInstanceTempCalendar();
            int hoursBg = (Integer.parseInt(startTime) / 60);
            int minutesBg = (Integer.parseInt(startTime) % 60);
            int hoursEnd = (Integer.parseInt(finishTime) / 60);
            int minutesEnd = (Integer.parseInt(finishTime) % 60);
            try {
              cal.setTimeInMillis(Long.parseLong(currentDate));
              if (hoursBg < cal.getMinimum(Calendar.HOUR_OF_DAY)) {
                hoursBg = 0;
                minutesBg = 0;
              }
              cal.set(Calendar.HOUR_OF_DAY, hoursBg);
              cal.set(Calendar.MINUTE, minutesBg);
              isMove = (eventCalendar.getFromDateTime().getTime() != cal.getTimeInMillis());
              eventCalendar.setFromDateTime(cal.getTime());
              if (hoursEnd >= 24) {
                hoursEnd = 23;
                minutesEnd = 59;
              }
              cal.set(Calendar.HOUR_OF_DAY, hoursEnd);
              cal.set(Calendar.MINUTE, minutesEnd);
              eventCalendar.setToDateTime(cal.getTime());
            } catch (Exception e) {
              if (log.isDebugEnabled()) {
                log.debug("Fail when calculate the time for calendar", e);
              }
              return;
            }
            if (eventCalendar.getToDateTime().before(eventCalendar.getFromDateTime())) {
              return;
            }
            // if it's a 'virtual' occurrence
            if (isOccur && !Utils.isEmpty(recurId)) {
              if (!isMove) {
                UIPopupAction pAction = uiCalendarPortlet.getChild(UIPopupAction.class);
                UIConfirmForm confirmForm = pAction.activate(UIConfirmForm.class, 480);
                confirmForm.setConfirmMessage("update-recurrence-event-confirm-msg");
                confirmForm.setDelete(false);
                confirmForm.setConfig_id(calendarview.getId());
                calendarview.setCurrentOccurrence(eventCalendar);
                event.getRequestContext().addUIComponentToUpdateByAjax(pAction);
              } else {
                calService = CalendarUtils.getCalendarService();
                CalendarEvent originEvent = calService.getRepetitiveEvent(eventCalendar);
                calService.saveOneOccurrenceEvent(originEvent, eventCalendar, username);
              }
              // return;
              // List<CalendarEvent> listEvent = new ArrayList<CalendarEvent>();
              // listEvent.add(eventCalendar);
              // calendarService.updateOccurrenceEvent(calendarId, calendarId, calType, calType,
              // listEvent, username);
            } else {
              if (calType.equals(CalendarUtils.PRIVATE_TYPE)) {
                calendarService.saveUserEvent(username, calendarId, eventCalendar, false);
              } else if (calType.equals(CalendarUtils.SHARED_TYPE)) {
                calendarService.saveEventToSharedCalendar(
                    username, calendarId, eventCalendar, false);
              } else if (calType.equals(CalendarUtils.PUBLIC_TYPE)) {
                calendarService.savePublicEvent(calendarId, eventCalendar, false);
              }
            }
            calendarview.setLastUpdatedEventId(eventId);
            calendarview.refresh();
            UIMiniCalendar uiMiniCalendar =
                uiCalendarPortlet.findFirstComponentOfType(UIMiniCalendar.class);
            event.getRequestContext().addUIComponentToUpdateByAjax(uiMiniCalendar);
            if (isOccur) {
              event.getRequestContext().addUIComponentToUpdateByAjax(calendarview);
            } else {
              JavascriptManager jsManager = event.getRequestContext().getJavascriptManager();
              RequireJS requireJS = jsManager.getRequireJS();
              requireJS.require("PORTLET/calendar/CalendarPortlet", "cal");
              requireJS.addScripts("cal.UIWeekView.setSize();cal.UIWeekView.cleanUp();");
            }
          }
        } catch (PathNotFoundException e) {
          if (log.isDebugEnabled()) {
            log.debug("The calendar is not found", e);
          }
          event
              .getRequestContext()
              .getUIApplication()
              .addMessage(new ApplicationMessage("UICalendars.msg.have-no-calendar", null, 1));
        } catch (Exception ex) {
          if (log.isDebugEnabled()) {
            log.debug("The calendar is not found", ex);
          }
        }
      }
    }
Ejemplo n.º 6
0
  /** used in template */
  private String renderEventBoard() throws Exception {
    StringBuilder stringBuilder = new StringBuilder();

    stringBuilder.append("\n<div class=\"eventBoard\">");

    Calendar cl = getBeginDateOfWeek();
    int t = 0;
    int numberOfDays = isShowCustomView_ ? 5 : 7;
    String styleWidth = isShowCustomView_ ? "width:19.8%;*width:20%;" : "width:13.8%;*width:14%;";

    while (t++ < numberOfDays) {
      int day = cl.get(Calendar.DATE);
      int month = cl.get(Calendar.MONTH);
      int year = cl.get(Calendar.YEAR);
      String key = keyGen(day, month, year);
      int dayOfWeek = cl.get(Calendar.DAY_OF_WEEK);
      List<CalendarEvent> events = getEventData().get(key);
      if (events != null) {
        for (CalendarEvent event : events) {
          String eventId = event.getId();
          String begin = tf.format(event.getFromDateTime());
          String begindate = dtf.format(event.getFromDateTime());
          String end = tf.format(event.getToDateTime());
          Calendar cal = CalendarUtils.getInstanceTempCalendar();
          cal.setTime(event.getFromDateTime());
          int beginTime = cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE);
          cal.setTime(event.getToDateTime());
          int endTime = cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE);
          String color =
              getColors().get(event.getCalType() + CalendarUtils.COLON + event.getCalendarId());
          String actionLink = event("UpdateEvent", eventId);
          boolean isOccur =
              (event.getRepeatType() != null
                  && !CalendarEvent.RP_NOREPEAT.equals(event.getRepeatType())
                  && (event.getIsExceptionOccurrence() == null
                      || !event.getIsExceptionOccurrence()));
          String recurId = event.getRecurrenceId();
          boolean isEditable;
          if (!event.getCalType().equals(CalendarUtils.PRIVATE_TYPE))
            isEditable = isEventEditable(event);
          else isEditable = true;

          stringBuilder
              .append(
                  "\n<div class=\"eventContainerBorder weekViewEventBoxes "
                      + color
                      + "\" eventindex=\""
                      + dayOfWeek
                      + "\"")
              .append(
                  " style=\"position: absolute;display:none\" eventcat=\""
                      + event.getEventCategoryId()
                      + "\" caltype=\""
                      + event.getCalType()
                      + "\"")
              .append(
                  " eventid=\""
                      + eventId
                      + "\" calid=\""
                      + event.getCalendarId()
                      + "\" actionlink=\""
                      + actionLink
                      + "\" unselectable=\"on\"")
              .append(
                  " startTime=\""
                      + beginTime
                      + "\" endTime=\""
                      + endTime
                      + "\" isOccur=\""
                      + isOccur
                      + "\" recurId=\""
                      + recurId
                      + "\" isEditable=\""
                      + isEditable
                      + "\">");

          if (!eventList.contains(eventId)) {
            eventList.add(eventId);

            stringBuilder
                .append(
                    "\n<input type=\"hidden\" name=\""
                        + eventId
                        + "calType\" value=\""
                        + event.getCalType()
                        + "\" />")
                .append(
                    "\n<input type=\"hidden\" name=\""
                        + eventId
                        + "calendarId\" value=\""
                        + event.getCalendarId()
                        + "\" />")
                .append("\n<input type=\"hidden\" name=\"" + eventId + "startTime\" value=\"\" />")
                .append("\n<input type=\"hidden\" name=\"" + eventId + "finishTime\" value=\"\" />")
                .append(
                    "\n<input type=\"hidden\" name=\""
                        + eventId
                        + "isOccur\" value=\""
                        + isOccur
                        + "\" />")
                .append(
                    "\n<input type=\"hidden\" name=\""
                        + eventId
                        + "recurId\" value=\""
                        + recurId
                        + "\" />")
                .append(
                    "\n<input type=\"hidden\" name=\"" + eventId + "currentDate\" value=\"\" />");
          }

          /** display event duration */
          if (event.isEventDurationSmallerThanHalfHour()) {
              /** short event */
            stringBuilder
                .append("\n<div class=\"clearfix\">")
                .append(
                    "\n<div unselectable=\"on\" class=\"eventContainerBar eventTitle pull-left\" style=\" display: inline-block; \">");

            if (CalendarEvent.TYPE_TASK.equals(event.getEventType())) {
              stringBuilder.append("\n<i class=\"uiIconCalTaskMini\"></i>");
            } else {
              stringBuilder.append("\n<i class=\"uiIconCalClockMini\"></i>");
              // occurring icon
              if (isOccur) {
                stringBuilder.append("<i class=\"uiIconCalRecurring\"></i>");
              } else if (!isOccur && Boolean.TRUE.equals(event.getIsExceptionOccurrence())) {
                stringBuilder.append("<i class=\"uiIconCalEditRecurring\"></i>");
              }
            }

            stringBuilder.append(
                "\n<i class=\"uiIconCal"
                    + event.getPriority()
                    + "Priority\"></i>"
                    + begin
                    + "</div>");

            /** display event summary */
            if ((event.getEventType().equals(CalendarEvent.TYPE_TASK))
                && (event.getEventState().equals(CalendarEvent.COMPLETED))) {
              stringBuilder.append(
                  "\n<div unselectable=\"on\" class=\"eventContainer\" style=\"text-decoration:line-through; \">"
                      + event.getSummary()
                      + "</div>");
            } else {
              stringBuilder.append(
                  "\n<div class=\"eventContainer \" >" + event.getSummary() + "</div>");
            }
            stringBuilder.append("</div>");
          } else {

            stringBuilder.append(
                "\n<div unselectable=\"on\" class=\"eventContainerBar eventTitle\">");

            if (CalendarEvent.TYPE_TASK.equals(event.getEventType())) {
              stringBuilder.append("\n<i class=\"uiIconCalTaskMini\"></i>");
            } else {
              stringBuilder.append("\n<i class=\"uiIconCalClockMini\"></i>");
              // occurring icon
              if (isOccur) {
                stringBuilder.append("<i class=\"uiIconCalRecurring\"></i>");
              } else if (!isOccur && Boolean.TRUE.equals(event.getIsExceptionOccurrence())) {
                stringBuilder.append("<i class=\"uiIconCalEditRecurring\"></i>");
              }
            }

            stringBuilder
                .append("\n<i class=\"uiIconCal" + event.getPriority() + "Priority\"></i>")
                .append(begin + " - " + end + "</div>");

            if ((event.getEventType().equals(CalendarEvent.TYPE_TASK))
                && (event.getEventState().equals(CalendarEvent.COMPLETED))) {
              stringBuilder
                  .append(
                      "\n<div unselectable=\"on\" class=\"eventContainer\" style=\" text-decoration:line-through; \">")
                  .append(event.getSummary() + "</div>");
            } else {
              stringBuilder.append(
                  "\n<div class=\"eventContainer\">" + event.getSummary() + "</div>");
            }
          }

          stringBuilder
              .append("\n<div class=\"resizeEventContainer\" unselectable=\"on\">")
              .append("\n<span></span>\n</div>\n</div>");
        }
      }
      cl.add(Calendar.DATE, 1);
    }

    stringBuilder
        .append("\n</div>")
        .append(
            "\n<table style=\"table-layout:fixed;\" class=\"uiGrid table \" id=\"UIWeekViewGrid\" lastupdatedid=\""
                + getLastUpdatedEventId()
                + "\"")
        .append(" cellspacing=\"0\" cellpadding=\"0\">")
        .append("\n<tbody>");

    boolean flag = false;
    String style = isShowWorkingTime() ? "WorkOffTime" : "none";
    String styleClass;

    String tempTimeFormat = CalendarUtils.TIMEFORMATPATTERNS[0];
    if (getTimeFormat().startsWith("HH")) tempTimeFormat = CalendarUtils.TIMEFORMATPATTERNS[1];
    int counter = 0;
    String timeName = "Gray";
    for (String full : getDisplayTimes(tempTimeFormat, getTimeInterval(), Locale.ENGLISH)) {
      if ((counter % 4) == 0 || (counter % 4) == 1) {
        timeName = "OddRow";
      } else if ((counter % 4) == 2 || (counter % 4) == 3) {
        timeName = "EvenRow";
      }

      String time = full.substring(0, full.lastIndexOf("_"));
      String display = full.substring(full.lastIndexOf("_") + 1);
      if (isShowWorkingTime()) {
        if (time.equals(getStartTime())) {
          style = "";
        }
        if (time.equals(getEndTime())) {
          style = "WorkOffTime";
        }
      }

      if (flag) {
        styleClass = "tdDotLine";
      } else {
        styleClass = "tdLine";
      }

      stringBuilder.append("\n<tr class=\"" + style + " " + timeName + "\">");

      if (!flag) {
        stringBuilder.append("\n<td class=\"tdTime center\" style=\"width: 55px;\">");
      } else {
        stringBuilder.append("\n<td style=\"width: 55px;\">");
      }

      stringBuilder.append("\n<div>");
      if (!flag) {
        stringBuilder.append(display);
      } else {
        stringBuilder.append("&nbsp;");
      }

      stringBuilder.append("\n</div>\n</td>");

      cl = getBeginDateOfWeek();
      DateFormat dayFormat = new SimpleDateFormat(getDateFormat(), Locale.ENGLISH);
      DateFormat fullDateFormat =
          new SimpleDateFormat(getDateFormat() + " " + CalendarUtils.TIMEFORMAT, Locale.ENGLISH);
      dayFormat.setCalendar(cl);
      fullDateFormat.setCalendar(cl);

      t = 0;
      String cssClass;
      while (t++ < numberOfDays) {
        // df.setCalendar(cl) ;
        String startTime = dayFormat.format(cl.getTime()) + " " + time;
        // dtf.setCalendar(cl) ;
        fullDateFormat.setLenient(false);
        // add try-catch block to handle Daylight Saving Time problem
        try {
          cl.setTime(fullDateFormat.parse(startTime));
        } catch (ParseException e) {
          fullDateFormat.setLenient(true);
          cl.setTime(fullDateFormat.parse(startTime));
        }
        int dayOfWeek = cl.get(Calendar.DAY_OF_WEEK);
        if (isCurrentDay(cl.get(Calendar.DATE), cl.get(Calendar.MONTH), cl.get(Calendar.YEAR))) {
          cssClass = "today";
        } else if (dayOfWeek == 1 || dayOfWeek == 7) {
          cssClass = "Weekend";
        } else {
          cssClass = "Weekday";
        }

        stringBuilder
            .append(
                "\n<td startFull=\""
                    + tempFormat.format(cl.getTime())
                    + "\" startTime=\""
                    + cl.getTimeInMillis()
                    + "\"")
            .append(
                " eventindex=\""
                    + dayOfWeek
                    + "\" class=\""
                    + styleClass
                    + " "
                    + cssClass
                    + " "
                    + style
                    + "\" style=\""
                    + styleWidth
                    + "\">")
            .append("\n<span></span>\n</td>");
        cl.add(Calendar.DATE, 1);
      }
      flag = !flag;

      stringBuilder.append("</tr>");
      counter++;
    }
    stringBuilder.append("\n</tbody>\n</table>");

    return stringBuilder.toString();
  }
Ejemplo n.º 7
0
  /** used in template */
  private String renderAllDayGrid() throws Exception {
    int numberOfDays = isShowCustomView_ ? 5 : 7;
    String styleWidth = isShowCustomView_ ? "width:19.8%;*width:20%;" : "width:13.8%;*width:14%;";

    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder
        .append(
            "\n<div id=\"UIWeekViewGridAllDay\" class=\"eventAllDay\" numberOfDays=\""
                + numberOfDays
                + "\">")
        .append("\n<div class=\"eventAlldayBoard\" style=\"position:relative\">")
        .append(
            "\n<table style=\"table-layout:fixed;\" class=\"uiGrid table allDayTable \" cellspacing=\"0\" cellpadding=\"0\">")
        .append("\n<tr>")
        .append("\n<td style=\"width: 55px;\"></td>");

    Calendar cl = getBeginDateOfWeek();
    int t = 0;
    while (t++ < numberOfDays) {

      stringBuilder.append(
          "\n<td class=\"whiteTd\" style=\""
              + styleWidth
              + "\" startTimeFull=\""
              + tempFormat.format(cl.getTime())
              + "\"></td>");
      cl.add(Calendar.DATE, 1);
    }
    stringBuilder.append("\n</tr>").append("\n</table>");

    for (CalendarEvent event : allDayEvent) {
      long begindate = event.getFromDateTime().getTime();
      long enddate = event.getToDateTime().getTime();
      // long startTime  = event.getFromDateTime().getTime() ;
      // long finishTime = event.getToDateTime().getTime() ;
      String eventId = event.getId();
      String calType = event.getCalType();
      String calendarId = event.getCalendarId();
      String color = getColors().get(calType + CalendarUtils.COLON + calendarId);
      // String title    = tf.format(event.getFromDateTime()) + "->" +
      // tf.format(event.getToDateTime())+ ":&#013; " + event.getSummary() ;
      String actionLink = event("UpdateAllDayEvent", eventId);
      boolean isOccur =
          (event.getRepeatType() != null
              && !CalendarEvent.RP_NOREPEAT.equals(event.getRepeatType())
              && (event.getIsExceptionOccurrence() == null || !event.getIsExceptionOccurrence()));
      String recurId = event.getRecurrenceId();
      boolean isEditable;
      if (!event.getCalType().equals(CalendarUtils.PRIVATE_TYPE))
        isEditable = isEventEditable(event);
      else isEditable = true;

      stringBuilder
          .append(
              "\n<div class=\"eventContainer eventAlldayContainer weekViewEventBoxes clearfix\" eventcat=\""
                  + event.getEventCategoryId()
                  + "\" style=\"position:absolute;display:none;\"")
          .append(
              "\n caltype=\""
                  + calType
                  + "\" eventid=\""
                  + eventId
                  + "\" isOccur=\""
                  + isOccur
                  + "\" recurId=\""
                  + recurId
                  + "\"")
          .append(
              "\n calid=\""
                  + calendarId
                  + "\" startTime=\""
                  + begindate
                  + "\" endTime=\""
                  + enddate
                  + "\"")
          .append(
              "\n startTimeFull=\""
                  + tempFormat.format(event.getFromDateTime())
                  + "\" endTimeFull=\""
                  + tempFormat.format(event.getToDateTime())
                  + "\"")
          .append("\n actionlink=\"" + actionLink + "\" isEditable=\"" + isEditable + "\">");

      if (!eventList.contains(eventId)) {
        eventList.add(eventId);

        stringBuilder
            .append(
                "\n<input type=\"hidden\" name=\""
                    + eventId
                    + "calType\" value=\""
                    + calType
                    + "\" />")
            .append(
                "\n<input type=\"hidden\" name=\""
                    + eventId
                    + "calendarId\" value=\""
                    + calendarId
                    + "\" />")
            .append("\n<input type=\"hidden\" name=\"" + eventId + "startTime\" value=\"\" />")
            .append("\n<input type=\"hidden\" name=\"" + eventId + "finishTime\" value=\"\" />")
            .append(
                "\n<input type=\"hidden\" name=\""
                    + eventId
                    + "isOccur\" value=\""
                    + isOccur
                    + "\" />")
            .append(
                "\n<input type=\"hidden\" name=\""
                    + eventId
                    + "recurId\" value=\""
                    + recurId
                    + "\" />")
            .append("\n<input type=\"hidden\" name=\"" + eventId + "currentDate\" value=\"\" />");
      }

      if (event.getFromDateTime().before(getBeginDateOfWeek().getTime())) {
        stringBuilder
            .append("\n<div class=\"leftContinueEvent  pull-left " + color + "\">")
            .append("\n<i class=\"uiIconMiniArrowLeft uiIconWhite\"></i>")
            .append("\n</div>");
      } else {
        stringBuilder
            .append(
                "\n<div class=\"leftResizeEvent LeftResizeEvent resizeEventContainer pull-left "
                    + color
                    + "\">")
            .append("\n<span></span>\n</div>");
      }

      if (event.getToDateTime().after(getEndDateOfWeek().getTime())) {
        stringBuilder
            .append("\n<div class=\"rightContinueEvent pull-right " + color + "\">")
            .append("\n<i class=\"uiIconMiniArrowRight uiIconWhite\"></i>\n</div>");
      } else {
        stringBuilder
            .append(
                "\n<div class=\"rightResizeEvent RightResizeEvent resizeEventContainer pull-right "
                    + color
                    + "\">")
            .append("\n<span></span>\n</div>");
      }

      stringBuilder
          .append(
              "\n<div class=\"eventAlldayContent " + color + "\">" + event.getSummary() + "</div>")
          .append("\n</div>");
    }
    stringBuilder.append("\n</div>\n</div>");

    return stringBuilder.toString();
  }
Ejemplo n.º 8
0
  @Override
  public void refresh() throws Exception {
    init();
    eventData_.clear();
    allDayEvent.clear();
    int i = 0;
    Calendar c = getBeginDateOfWeek();
    int maxDay = 7;
    if (isShowCustomView_) maxDay = 5;
    while (i++ < maxDay) {
      List<CalendarEvent> list = new ArrayList<CalendarEvent>();
      String key = keyGen(c.get(Calendar.DATE), c.get(Calendar.MONTH), c.get(Calendar.YEAR));
      eventData_.put(key, list);
      c.add(Calendar.DATE, 1);
    }
    CalendarService calendarService = CalendarUtils.getCalendarService();
    String username = CalendarUtils.getCurrentUser();
    EventQuery eventQuery = new EventQuery();
    eventQuery.setFromDate(getBeginDateOfWeek());
    Calendar endDateOfWeek = getEndDateOfWeek();
    Date toDate = endDateOfWeek.getTime();
    toDate.setTime(toDate.getTime() - 1);
    endDateOfWeek.setTime(toDate);
    eventQuery.setToDate(endDateOfWeek);
    eventQuery.setExcludeRepeatEvent(true);

    /** get all norepeat events */
    List<CalendarEvent> allEvents;
    String[] publicCalendars = getPublicCalendars();
    String[] privateCalendars = getPrivateCalendars().toArray(new String[] {});

    if (isInSpace()) {
      eventQuery.setCalendarId(publicCalendars);
      allEvents = calendarService.getPublicEvents(eventQuery);
    } else {
      allEvents =
          calendarService.getAllNoRepeatEventsSQL(
              username, eventQuery, privateCalendars, publicCalendars, emptyEventCalendars);
    }

    /** get exception occurrences, exclude original recurrence events */
    List<CalendarEvent> originalRecurEvents =
        calendarService.getHighLightOriginalRecurrenceEventsSQL(
            username,
            eventQuery.getFromDate(),
            eventQuery.getToDate(),
            eventQuery,
            privateCalendars,
            publicCalendars,
            emptyRecurrentEventCalendars);

    String timezone = CalendarUtils.getCurrentUserCalendarSetting().getTimeZone();
    if (originalRecurEvents != null && originalRecurEvents.size() > 0) {
      Iterator<CalendarEvent> recurEventsIter = originalRecurEvents.iterator();
      while (recurEventsIter.hasNext()) {
        CalendarEvent recurEvent = recurEventsIter.next();
        Map<String, CalendarEvent> tempMap =
            calendarService.getOccurrenceEvents(
                recurEvent, eventQuery.getFromDate(), eventQuery.getToDate(), timezone);
        if (tempMap != null) {
          recurrenceEventsMap.put(recurEvent.getId(), tempMap);
          allEvents.addAll(tempMap.values());
        }
      }
    }

    Iterator<CalendarEvent> iter = allEvents.iterator();
    while (iter.hasNext()) {
      CalendarEvent event = iter.next();
      Date beginEvent = event.getFromDateTime();
      Date endEvent = event.getToDateTime();
      long eventAmount = endEvent.getTime() - beginEvent.getTime();
      i = 0;
      c = getBeginDateOfWeek();
      while (i++ < maxDay) {
        String key = keyGen(c.get(Calendar.DATE), c.get(Calendar.MONTH), c.get(Calendar.YEAR));
        if (isSameDate(c.getTime(), beginEvent)
            && (isSameDate(c.getTime(), endEvent))
            && eventAmount < CalendarUtils.MILISECONS_OF_DAY) {
          eventData_.get(key).add(event);
          iter.remove();
        }
        c.add(Calendar.DATE, 1);
      }
    }

    for (CalendarEvent ce : allEvents) {
      allDayEvent.add(ce);
    }
  }
  private Map<String, String> buildParams(CalendarEvent oldEvent, CalendarEvent newEvent) {
    Map<String, String> messagesParams = new LinkedHashMap<String, String>();
    try {
      if (CalendarEvent.TYPE_EVENT.equals(newEvent.getEventType())) {
        if (!oldEvent.getSummary().equals(newEvent.getSummary())) {
          messagesParams.put(SUMMARY_UPDATED, newEvent.getSummary());
        }

        /* change description */
        if (newEvent.getDescription() != null
            && !newEvent.getDescription().equals(oldEvent.getDescription())) {
          messagesParams.put(DESCRIPTION_UPDATED, newEvent.getDescription());
        }
        /* remove description */
        else if ((newEvent.getDescription() == null) && (oldEvent.getDescription() != null)) {
          messagesParams.put(DESCRIPTION_REMOVED, "");
        }

        /* change location */
        if (newEvent.getLocation() != null
            && !newEvent.getLocation().equals(oldEvent.getLocation())) {
          messagesParams.put(LOCATION_UPDATED, newEvent.getLocation());
        }
        /* remove location */
        else if ((newEvent.getLocation() == null) && (oldEvent.getLocation() != null)) {
          messagesParams.put(LOCATION_REMOVED, "");
        }

        if (newEvent.getPriority() != null
            && !newEvent.getPriority().equals(oldEvent.getPriority())) {
          messagesParams.put(PRIORITY_UPDATED, newEvent.getPriority());
        }
        if (newEvent.getAttachment() != null)
          if (oldEvent.getAttachment() == null) {
            messagesParams.put(ATTACH_UPDATED, "");
          } else if (newEvent.getAttachment().size() != oldEvent.getAttachment().size()) {
            messagesParams.put(ATTACH_UPDATED, "");
          }
        if (isAllDayEvent(newEvent)
            && !isAllDayEvent(oldEvent)
            && CalendarEvent.TYPE_EVENT.equals(oldEvent.getEventType())) {
          messagesParams.put(ALLDAY_UPDATED, "");
        } else if (!isAllDayEvent(newEvent)) {
          if (newEvent.getFromDateTime().compareTo(oldEvent.getFromDateTime()) != 0) {
            messagesParams.put(FROM_UPDATED, String.valueOf(newEvent.getFromDateTime().getTime()));
          }
          if (newEvent.getToDateTime().compareTo(oldEvent.getToDateTime()) != 0) {
            messagesParams.put(TO_UPDATED, String.valueOf(newEvent.getToDateTime().getTime()));
          }
        }

        /*=== compare the repeat type ===*/
        String repeatSummary = buildRepeatSummary(newEvent);
        if (!repeatSummary.equals(buildRepeatSummary(oldEvent))) {
          messagesParams.put(REPEAT_UPDATED, repeatSummary);
        }

        /*=== compare the activity id ===*/
        // oldEvent -- occurrence or instance of repetitive event -- no activity
        // newEvent -- repetitiveEvent - with activity
        if (!newEvent.getActivityId().equals(oldEvent.getActivityId())) {
          messagesParams.put(
              REPEAT_EVENT_INSTANCE_REMOVED,
              getDateFormattedAfterUserSetting(oldEvent.getRecurrenceId()));
        }

      } else {
        if (!oldEvent.getSummary().equals(newEvent.getSummary())) {
          messagesParams.put(NAME_UPDATED, newEvent.getSummary());
        }
        /* change note */
        if (newEvent.getDescription() != null
            && !newEvent.getDescription().equals(oldEvent.getDescription())) {
          messagesParams.put(NOTE_UPDATED, newEvent.getDescription());
        }
        /* removed note */
        else if ((newEvent.getDescription() == null) && (oldEvent.getDescription() != null)) {
          messagesParams.put(NOTE_REMOVED, "");
        }

        if (!isAllDayEvent(newEvent)) {
          if (newEvent.getFromDateTime().compareTo(oldEvent.getFromDateTime()) != 0) {
            messagesParams.put(FROM_UPDATED, String.valueOf(newEvent.getFromDateTime().getTime()));
          }
          if (newEvent.getToDateTime().compareTo(oldEvent.getToDateTime()) != 0) {
            messagesParams.put(TO_UPDATED, String.valueOf(newEvent.getToDateTime().getTime()));
          }
        }
        if (newEvent.getPriority() != null
            && !newEvent.getPriority().equals(oldEvent.getPriority())) {
          messagesParams.put(PRIORITY_UPDATED, newEvent.getPriority());
        }
        if (newEvent.getAttachment() != null)
          if (oldEvent.getAttachment() == null) {
            messagesParams.put(TASK_ATTACH_UPDATED, "");
          } else if (newEvent.getAttachment().size() != oldEvent.getAttachment().size()) {
            messagesParams.put(TASK_ATTACH_UPDATED, "");
          }
        if (newEvent.getEventState() != null
            && !newEvent.getEventState().equals(oldEvent.getEventState())) {
          if (CalendarEvent.NEEDS_ACTION.equals(newEvent.getEventState())) {
            messagesParams.put(TASK_NEED_ACTION, newEvent.getEventState());
          } else if (CalendarEvent.IN_PROCESS.equals(newEvent.getEventState())) {
            messagesParams.put(TASK_IN_PROCESS_ACTION, newEvent.getEventState());
          } else if (CalendarEvent.COMPLETED.equals(newEvent.getEventState())) {
            messagesParams.put(TASK_COMPLETED_ACTION, newEvent.getEventState());
          } else if (CalendarEvent.CANCELLED.equals(newEvent.getEventState())) {
            messagesParams.put(TASK_CANCELLED_ACTION, newEvent.getEventState());
          }
        }
      }
    } catch (Exception e) {
      if (LOG.isDebugEnabled()) LOG.error("Can not build message for space when event updated ", e);
    }
    return messagesParams;
  }