* Manager for date enrollments, provides methods for the enrollment procedure and persisting

* @author skoeber

*/

 

  private final static DENManager denManager = new DENManager();

  private CalendarManager calManager;

 

  private DENManager() {

    calManager = CalendarManagerFactory.getInstance().getCalendarManager();

  }

 

  /**

   * This method returns a reference of the static date enrollment manager (singleton pattern)

   * @return instance of DENManager

   */

  public static DENManager getInstance() {

    return denManager;

  }

  /**

   * Enrolls an user into a specific calendar event

   * @param identity

   * @param event

   * @param course

   * @param courseNode

   * @return status

   */

  public DENStatus doEnroll(final Identity identity, final KalendarEvent event, final OLATResourceable ores, final DENCourseNode courseNode) {

    return doEnroll(identity, event, ores, courseNode, false);

  }

  /**

   * Enrolls an user into a specific calendar event

   * @param identity

   * @param event

   * @param course

   * @param courseNode

   * @param allowOverfill

   * @return status

   */

  public DENStatus doEnroll(final Identity identity, final KalendarEvent event, final OLATResourceable ores, final DENCourseNode courseNode,

      final boolean allowOverfill) {

    final DENStatus status = new DENStatus();

    ICourse course = CourseFactory.loadCourse(ores);

    final Kalendar cal = calManager.getCourseCalendar(course).getKalendar();

    OLATResourceable calRes = calManager.getOresHelperFor(cal);

    CoordinatorManager.getCoordinator().getSyncer().doInSync(calRes, new SyncerExecutor() {

      public void execute() {

        boolean error = false;

        Collection<KalendarEvent> collEvents = cal.getEvents();

        // check if date is already full

        if (!allowOverfill && isDateFull(event)) {

          status.setEnrolled(false);

          status.setErrorMessage(DENStatus.ERROR_FULL);

          error = true;

        }

        // check if identity is already enrolled

        if (!error && isAlreadyEnrolled(identity, collEvents, courseNode)) {

          status.setEnrolled(false);

          status.setErrorMessage(DENStatus.ERROR_ALREADY_ENROLLED);

          error = true;

        }

        // enroll in event

        if (!error) {

          if (event.getParticipants() != null && event.getParticipants().length > 0) {

            int currLength = event.getParticipants().length;

            String[] partsNew = new String[currLength + 1]; // one to add

            String[] partsOld = event.getParticipants();

            for (int i = 0; i < partsOld.length; i++) {

              partsNew[i] = partsOld[i];

            }

            partsNew[partsNew.length - 1] = identity.getName();

            event.setParticipants(partsNew);

          } else {

            String[] partsNew = new String[] { identity.getName() };

            event.setParticipants(partsNew);

          }

          // save calendar event

          boolean successfullyDone = calManager.updateEventAlreadyInSync(cal, event);

          if (!successfullyDone) {

            status.setEnrolled(false);

            status.setErrorMessage(DENStatus.ERROR_PERSISTING);

          }

          status.setEnrolled(true);

        }

      }

    });

    // success

    return status;

  }

 

  /**

   * Deletes the already enrolled user from the date

   * @param identity

   * @param event

   * @param course

   * @param userCourseEnv

   * @return status

   */

  public DENStatus cancelEnroll(Identity identity, KalendarEvent event, OLATResourceable ores, DENCourseNode courseNode) {

    DENStatus status = new DENStatus();

    ICourse course = CourseFactory.loadCourse(ores);

    Kalendar cal = calManager.getCourseCalendar(course).getKalendar();

    Collection<KalendarEvent> collEvents = cal.getEvents();

    //check if identity is enrolled

    if( !isEnrolledInDate(identity, event) ) {

      status.setCancelled(false);

      status.setErrorMessage(DENStatus.ERROR_NOT_ENROLLED);

    }

    //cancel enroll in calendar entry

    if(event.getParticipants() != null) {

      int currLength = event.getParticipants().length;

      if (currLength > 1) {

        //more than one are enrolled

        String[] partsNew = new String[currLength - 1]; //one to delete

        String[] partsOld = event.getParticipants();

        String identityName = identity.getName();

        for (int i = 0, j = 0; i < partsOld.length; i++) {

          if ( !(partsOld[i].equals(identityName)) ) {

            partsNew[j] = partsOld[i];

            j++; //only increment if new entry was made

          }

        }

        event.setParticipants(partsNew);

      } else if (currLength == 1) {

        //only one is enrolled, only simple reset needed

        event.setParticipants(new String[0]);

      }

      //save calendar event

      boolean successfullyDone = calManager.updateEventFrom(cal, event);

      if (!successfullyDone) {

        status.setCancelled(false);

        status.setErrorMessage(DENStatus.ERROR_PERSISTING);

        return status;

      }

    } else {

      //no one to cancel

      status.setCancelled(false);

      status.setErrorMessage(DENStatus.ERROR_GENERAL);

      return status;

    }

    status.setCancelled(true);

    //delete date from the users calendar

    Kalendar userCal = calManager.getPersonalCalendar(identity).getKalendar();

    Collection<KalendarEvent> userEvents = userCal.getEvents();

    String sourceNodeId = event.getSourceNodeId();

    for( KalendarEvent userEvent : userEvents) {

      String eventSourceNodeId = userEvent.getSourceNodeId();

      if(eventSourceNodeId != null && eventSourceNodeId.equals(sourceNodeId)) {

        calManager.removeEventFrom(userCal, userEvent);

        break;

      }

    }

    //success

    return status;

  }

 

  /**

   * Persists settings of the date enrollment

   * @param lstEvents

   * @param course

   * @param denNode

   */

  public void persistDENSettings(List<KalendarEvent> lstEvents, OLATResourceable ores, DENCourseNode denNode) {

    ICourse course = CourseFactory.loadCourse(ores);

    Kalendar cal = calManager.getCourseCalendar(course).getKalendar();

    String sourceNode = denNode.getIdent();

    //remove deleted events

    Collection<KalendarEvent> allEvents = new ArrayList<KalendarEvent>(cal.getEvents());

    for( KalendarEvent event : allEvents) {

      if(event.getSourceNodeId() != null) {

        if ( event.getSourceNodeId().equals(sourceNode) && !lstEvents.contains(event) ) {

          removeDateInUserCalendar(event);

          calManager.removeEventFrom(cal, event);

        }

      }

    }

    for( KalendarEvent newEvent : lstEvents ) {

      createKalendarEventLinks(course, denNode, newEvent);

      KalendarEvent oldEvent = cal.getEvent(newEvent.getID());

      //new event?

      if (oldEvent != null) {

        //event is already in the calendar so first remove it

        calManager.removeEventFrom(cal, oldEvent);

      }

      //now add the event to the course calendar

      calManager.addEventTo(cal, newEvent);

      //update event in user calendars

      addDateInUserCalendar(newEvent);

    }

  }

 

  /**

   * Checks if person is enrolled in specific calendar entry

   * @param identity

   * @param event

   * @return true if person is enrolled, otherwise false

   */

  protected boolean isEnrolledInDate(Identity identity, KalendarEvent event) {

    if(event.getParticipants() == null)

      return false;

    return isSubstringInStringArray(identity.getName(), event.getParticipants());

  }

 

  /**

   * Checks if person is already enrolled in any calendar entry of this enrollment or not

   * @param identity

   * @param course

   * @param userCourseEnv

   * @return true if person already enrolled in one date, otherwise false

   */

  protected boolean isAlreadyEnrolled(Identity identity, Collection<KalendarEvent> collEvents, DENCourseNode courseNode) {

    boolean alreadyIn = false;

    for( KalendarEvent event : collEvents ) {

      //first check the correct course node and following if person is in

      if(event.getSourceNodeId() != null) {

        if(event.getSourceNodeId().equals(courseNode.getIdent()))//check the current course node

          alreadyIn = isEnrolledInDate(identity, event);//check every event if the identity is already in

      }

      if(alreadyIn == true) break;//if identity is in any date enrolled, break and return true

    }

    return alreadyIn;

  }

 

  /**

   * Checks if the number of maximum participants is reached

   * @param event

   * @return true if it is full, otherwise false

   */

  protected boolean isDateFull(KalendarEvent event) {

    if(event.getParticipants() != null) {

      if(event.getNumParticipants() == event.getParticipants().length)

        return true;

    }

   

    return false;

  }

 

  /**

   * Returns all generated Events for this course and node

   * @param courseId

   * @param sourseNodeId

   * @return List of all KalendarEvent in this date enrollment

   */

  protected List<KalendarEvent> getDENEvents(Long courseId, String sourceNodeId) {

    List<KalendarEvent> denEvents = new ArrayList<KalendarEvent>();

    ICourse course = CourseFactory.loadCourse(courseId);

    Kalendar cal = calManager.getCourseCalendar(course).getKalendar();

    Collection<KalendarEvent> colEvents = cal.getEvents();

    for( KalendarEvent event : colEvents) {

      String eventSourceNodeId = event.getSourceNodeId();

      if(eventSourceNodeId != null) {

        if(eventSourceNodeId.equals(sourceNodeId))

          denEvents.add(event);

      }

    }

   

    return denEvents;

  }

 

  /**

   * Count of dates for this date enrollment

   * @param courseRessourcableId

   * @param courseNodeIdent

   * @return number of dates

   */

  public int getEventCount(Long courseId, String courseNodeId) {

    if(courseId != null && courseNodeId != null) {

      List events = null;

      try {

        events = getDENEvents(courseId, courseNodeId);

      } catch(Exception e) {

        // nothing to do

      }

      if(events != null)

        return events.size();

    }

   

    return 0;

  }

 

//   * This method generates the needed dates from a given manage dates form

//   * @param datesForm of type DENEditManageDatesForm

//   * @param dataList

//   * @return List<KalendarEvent> with the generated dates

//   */

//  protected List<KalendarEvent> generateDates(DENDatesForm datesForm, List<KalendarEvent> dataList, DENCourseNode denCourseNode) {

//    Date nextEvent = null;

//    for (int i = 0; i < datesForm.getRetakes(); i++) {

//      StringTokenizer strTok = new StringTokenizer(datesForm.getDuration(), ":", false);

//      //duration in milliseconds

//      int duration = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

//      strTok = new StringTokenizer(datesForm.getPause(), ":", false);

//      //pause in milliseconds

//      int pause = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

//      KalendarEvent newEvent;

//      if(nextEvent == null) {

//        newEvent = new KalendarEvent(CodeHelper.getGlobalForeverUniqueID(), datesForm.getSubject(), datesForm.getBeginDate(), duration);

//      } else {

//        newEvent = new KalendarEvent(CodeHelper.getGlobalForeverUniqueID(), datesForm.getSubject(), nextEvent, duration);

//      }

//      newEvent.setNumParticipants(datesForm.getNumParts());

//      newEvent.setLocation(datesForm.getLocation());

//      newEvent.setComment(datesForm.getComment());

//      newEvent.setSourceNodeId(denCourseNode.getIdent());

//      dataList.add(newEvent);

//      //prepare next Event

//      long newTime = newEvent.getEnd().getTime() + pause;

//      nextEvent = new Date(newTime);

//    }

//   

//    return dataList;

//  }

  /**

   * This method generates the needed dates

   * @param retakes

   * @param durationStr

   * @param pauseStr

   * @param subjectStr

   * @param commentStr

   * @param locationStr

   * @param begin

   * @param numParticipants

   * @param dataList

   * @param denCourseNode

   * @return List<KalendarEvent> with the generated dates

   */

  protected List<KalendarEvent> generateDates(

      String subjectStr, String commentStr, String locationStr, String durationStr, String pauseStr,

      Date begin, int retakes, int numParticipants, List<KalendarEvent> dataList, String denCourseNodeId) {

    Date nextEvent = null;

    for (int i = 0; i < retakes; i++) {

      StringTokenizer strTok = new StringTokenizer(durationStr, ":", false);

      //duration in milliseconds

      int duration = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

      strTok = new StringTokenizer(pauseStr, ":", false);

      //pause in milliseconds

      int pause = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

      KalendarEvent newEvent;

      if(nextEvent == null) {

        newEvent = new KalendarEvent(CodeHelper.getGlobalForeverUniqueID(), subjectStr, begin, duration);

      } else {

        newEvent = new KalendarEvent(CodeHelper.getGlobalForeverUniqueID(), subjectStr, nextEvent, duration);

      }

      newEvent.setNumParticipants(numParticipants);

      newEvent.setLocation(locationStr);

      newEvent.setComment(commentStr);

      newEvent.setSourceNodeId(denCourseNodeId);

      dataList.add(newEvent);

      //prepare next Event

      long newTime = newEvent.getEnd().getTime() + pause;

      nextEvent = new Date(newTime);

    }

   

    return dataList;

  }

 

  /**

   * Update one date in a list of KalendarEvents with the given informations from a manage dates form

   * @param datesForm of type DENEditManageDatesForm

   * @param dataList

   * @param index

   * @return list with actualized KalendarEvents

   */

  protected List<KalendarEvent> updateDateInList(String subjectStr, String commentStr, String locationStr, String durationStr,

      Date begin, int numParticipants, List<KalendarEvent> dataList, int index) {

    StringTokenizer strTok = new StringTokenizer(durationStr, ":", false);

    int duration = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

    KalendarEvent oldEvent = dataList.get(index);

    KalendarEvent newEvent = new KalendarEvent(oldEvent.getID(), subjectStr, begin, duration);

    newEvent.setNumParticipants(numParticipants);

    newEvent.setLocation(locationStr);

    newEvent.setComment(commentStr);

    newEvent.setSourceNodeId(oldEvent.getSourceNodeId());

    newEvent.setParticipants(oldEvent.getParticipants());

    dataList.remove(index);

    dataList.add(index, newEvent);

   

    return dataList;

  }

 

  /**

   * Update multiple dates in a list of KalendarEvents with the given informations from a manage dates form

   * @param datesForm of type DENEditManageDatesForm

   * @param dataList

   * @param selectedDates

   * @return list with actualized KalendarEvents

   */

  protected List<KalendarEvent> updateMultipleDatesInList(String subjectStr, String commentStr, String locationStr,  String movementGapStr,

      int numParticipants, List<KalendarEvent> dataList, BitSet selectedDates) {

    for (int i = 0; i < dataList.size(); i++) {

      if(selectedDates.get(i)) {

        KalendarEvent oldEvent = dataList.get(i);

        StringTokenizer strTok = new StringTokenizer(movementGapStr.substring(1), ":", false);

        int gap = 1000*60*60*Integer.parseInt(strTok.nextToken()) + 1000*60*Integer.parseInt(strTok.nextToken());

        Date newBegin, newEnd;

        if(movementGapStr.startsWith("+")) {

          newBegin = new Date(oldEvent.getBegin().getTime() + gap);

          newEnd = new Date(oldEvent.getEnd().getTime() + gap);

        } else {

          newBegin = new Date(oldEvent.getBegin().getTime() - gap);

          newEnd = new Date(oldEvent.getEnd().getTime() - gap);

        }

        KalendarEvent newEvent = new KalendarEvent(dataList.get(i).getID(), subjectStr.equals(new String()) ? oldEvent.getSubject() : subjectStr, newBegin, newEnd);

        if(numParticipants != 0)

          newEvent.setNumParticipants(numParticipants);

        else

          newEvent.setNumParticipants(oldEvent.getNumParticipants());

        if(!locationStr.equals(new String()))

          newEvent.setLocation(locationStr);

        else

          newEvent.setLocation(oldEvent.getLocation());

        if(!commentStr.equals(new String()))

          newEvent.setComment(commentStr);

        else

          newEvent.setComment(oldEvent.getComment());

        newEvent.setParticipants(oldEvent.getParticipants());

        newEvent.setSourceNodeId(oldEvent.getSourceNodeId());

        dataList.remove(i);

        dataList.add(i, newEvent);

      }

    }

   

    return dataList;

  }

  /**

   * Add this event in the calendar of an enrolled user

   * @param newEvent

   */

  private void addDateInUserCalendar(KalendarEvent newEvent) {

    String[] participants = newEvent.getParticipants();

    if(participants == null) return;//no users to update, cancel

    Manager manager = ManagerFactory.getManager();

    for( String participant : participants ) {

      Identity identity = manager.findIdentityByName(participant);

      Kalendar userCal = calManager.getPersonalCalendar(identity).getKalendar();

      Collection<KalendarEvent> userEvents = new ArrayList<KalendarEvent>();

      userEvents.addAll(userCal.getEvents());

      KalendarEvent userNewEvent = new KalendarEvent(CodeHelper.getGlobalForeverUniqueID(), newEvent.getSubject(), newEvent.getBegin(), newEvent.getEnd());

      userNewEvent.setLocation(newEvent.getLocation());

      userNewEvent.setSourceNodeId(newEvent.getSourceNodeId());

      userNewEvent.setClassification(KalendarEvent.CLASS_PRIVATE);

      List kalendarEventLinks = userNewEvent.getKalendarEventLinks();

      kalendarEventLinks.clear();

      kalendarEventLinks.addAll(newEvent.getKalendarEventLinks());

      calManager.addEventTo(userCal, userNewEvent);

    }

  }

  /**

   * Removes this event in all calendars of enrolled users

   * @param oldEvent

   */

  private void removeDateInUserCalendar(KalendarEvent oldEvent) {

    String[] participants = oldEvent.getParticipants();

    if(participants == null) return;//no users to update, cancel

    Manager manager = ManagerFactory.getManager();

    for( String participant : participants ) {

      Identity identity = manager.findIdentityByName(participant);

      Kalendar userCal = calManager.getPersonalCalendar(identity).getKalendar();

      Collection<KalendarEvent> userEvents = new ArrayList<KalendarEvent>();

      userEvents.addAll(userCal.getEvents());

      for( KalendarEvent userEvent : userEvents ) {

        String sourceNodeId = userEvent.getSourceNodeId();

        if(sourceNodeId != null && sourceNodeId.equals(oldEvent.getSourceNodeId())) {

          calManager.removeEventFrom(userCal, userEvent);

        }

      }

    }

  }

  /**

   * Create the table for the manage dates view

   * @param ureq

   * @param wControl

   * @param trans

   * @param listener

   * @param tableData DENEditTableDataModel

   * @return TableController

   */

  protected TableController createManageDatesTable(UserRequest ureq, WindowControl wControl, Translator trans, DefaultController listener, DENEditTableDataModel tableData) {

    TableGuiConfiguration tableConfig = new TableGuiConfiguration();

    tableConfig.setColumnMovingOffered(true);

    tableConfig.setResultsPerPage(15);

    tableConfig.setShowAllLinkEnabled(true);

    TableController tableCntrl = new TableController(tableConfig, ureq, wControl, trans, listener);

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.date", 0, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.begin", 1, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.end", 2, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.location", 3, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.comment", 4, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participants.num", 5, null, ureq.getLocale()));

    tableCntrl.addMultiSelectAction("dates.table.edit.change", DENEditTableDataModel.CHANGE_ACTION);

    tableCntrl.addMultiSelectAction("dates.table.edit.delete", DENEditTableDataModel.DELETE_ACTION);

    tableCntrl.setMultiSelect(true);

    tableCntrl.setTableDataModel(tableData);

    tableCntrl.setSortColumn(2, true);//begin + multi select column

   

    return tableCntrl;

  }

 

  /**

   * Create the table for the run view

   * @param ureq

   * @param wControl

   * @param trans

   * @param listener

   * @param tableData DENRunTableDataModel

   * @return TableController

   */

  protected TableController createRunDatesTable(UserRequest ureq, WindowControl wControl, Translator trans, DefaultController listener, DENRunTableDataModel tableData) {

    TableGuiConfiguration tableConfig = new TableGuiConfiguration();

    tableConfig.setTableEmptyMessage(trans.translate("dates.table.empty"));

    tableConfig.setColumnMovingOffered(true);

    TableController tableCntrl = new TableController(tableConfig, ureq, wControl, trans, listener);

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.date", 0, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.begin", 1, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.end", 2, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.location", 3, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.comment", 4, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.reserved", 5, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.status", 6, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new BooleanColumnDescriptor("dates.table.sign.in", 7, DENRunTableDataModel.CMD_ENROLL_IN_DATE,

        trans.translate("dates.table.sign.in"), trans.translate("dates.table.run.no_action")));

    tableCntrl.addColumnDescriptor(new BooleanColumnDescriptor("dates.table.sign.out", 8, DENRunTableDataModel.CMD_ENROLLED_CANCEL,

        trans.translate("dates.table.sign.out"), trans.translate("dates.table.run.no_action")));

    tableCntrl.setTableDataModel(tableData);

    tableCntrl.setSortColumn(1, true);//timeframe

   

    return tableCntrl;

  }

 

  /**

   * Create the table for the list of participants view

   * @param ureq

   * @param wControl

   * @param trans

   * @param listener

   * @param tableData DENListTableDataModel

   * @return TableController

   */

  protected TableController createListParticipantsTable(UserRequest ureq, WindowControl wControl, Translator trans, DefaultController listener, DENListTableDataModel tableData) {

    TableGuiConfiguration tableConfig = new TableGuiConfiguration();

    tableConfig.setTableEmptyMessage(trans.translate("dates.table.empty"));

    tableConfig.setColumnMovingOffered(true);

    TableController tableCntrl = new TableController(tableConfig, ureq, wControl, trans, listener);

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.date", 0, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.begin", 1, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.end", 2, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.location", 3, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.comment", 4, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participant.name", 5, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participant.username", 6, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new BooleanColumnDescriptor("participants", 7, DENListTableDataModel.CHANGE_ACTION,

        trans.translate("dates.table.participant.manage"), ""));

    tableCntrl.addMultiSelectAction("dates.table.list.email", DENListTableDataModel.MAIL_ACTION);

    tableCntrl.addMultiSelectAction("dates.table.list.delete", DENListTableDataModel.DELETE_ACTION);

    tableCntrl.setMultiSelect(true);

    tableCntrl.setTableDataModel(tableData);

    tableCntrl.setSortColumn(2, true);//timeframe + multi select column

   

    return tableCntrl;

  }

 

  /**

   * Create the table for the participants management view

   * @param ureq

   * @param wControl

   * @param trans

   * @param listener

   * @param tableData DENParticipantsTableDataModel

   * @return TableController

   */

  protected TableController createParticipantsTable(UserRequest ureq, WindowControl wControl, Translator trans, DefaultController listener, DENParticipantsTableDataModel tableData) {

    TableGuiConfiguration tableConfig = new TableGuiConfiguration();

    tableConfig.setTableEmptyMessage(trans.translate("dates.table.empty"));

    tableConfig.setColumnMovingOffered(true);

    TableController tableCntrl = new TableController(tableConfig, ureq, wControl, trans, listener);

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participant.firstname", 0, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participant.lastname", 1, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new DefaultColumnDescriptor("dates.table.participant.email", 2, null, ureq.getLocale()));

    tableCntrl.addColumnDescriptor(new BooleanColumnDescriptor("dates.table.participant.email.send", 3, DENParticipantsTableDataModel.MAIL_ACTION,

        trans.translate("dates.table.participant.email.send"), ""));

    tableCntrl.addColumnDescriptor(new BooleanColumnDescriptor("dates.table.list.delete", 3, DENParticipantsTableDataModel.REMOVE_ACTION,

        trans.translate("dates.table.list.delete"), ""));

    tableCntrl.setTableDataModel(tableData);

   

    return tableCntrl;

  }

 

  /**

   * Delete all participants in the events with the given IDs

   * @param course

   * @param courseNode

   * @param eventIDs of the events, where all participants should be deleted

   * @return list with the actualized events

   */

  protected List<KalendarEvent> deleteParticipants(OLATResourceable ores, DENCourseNode courseNode, List<String> eventIDs) {

    List<KalendarEvent> events = getDENEvents(ores.getResourceableId(), courseNode.getIdent());

    for( KalendarEvent event : events ) {

      if(eventIDs.contains(event.getID())) {

        removeDateInUserCalendar(event);

        event.setParticipants(new String[0]);

      }

    }

    persistDENSettings(events, ores, courseNode);

    return events;

  }

 

  /**

   * Little helper method, that gives you all IDs of the selected events in the list

   * @param dataList

   * @param selection BitSet

   * @return list of strings with IDs

   */

  protected List<String> getSelectedEventIDs(List<KalendarEvent> dataList, BitSet selection) {

    List<String> lstIDs = new ArrayList<String>();

    for(int i = 0; i < dataList.size(); i++) {

      if(selection.get(i)) {

        lstIDs.add(dataList.get(i).getID());

      }

    }

   

    return lstIDs;

  }

 

  /**

   * Little helper method, that gives you all participants of the selected events in the list

   * @param dataList

   * @param selection BitSet

   * @return list of Identities

   */

  protected List<Identity> getSelectedEventParticipants(List<KalendarEvent> dataList, BitSet selection) {

    List<Identity> identities = new ArrayList<Identity>();

    Manager manager = ManagerFactory.getManager();

    for(int i = 0; i < dataList.size(); i++) {

      if(selection.get(i)) {

        String[] parts = dataList.get(i).getParticipants();

        if(parts != null) {

          for(String participant : parts) {

            Identity identity = manager.findIdentityByName(participant);

            if(identity != null)

              identities.add(identity);

          }

        }

      }

    }

    return identities;

  }

 

  /**

   * Little helper method, that gives you all participants of a specific event

   * @param event

   * @return list of Identities

   */

  protected List<Identity> getEventParticipants(KalendarEvent event) {

    List<Identity> identities = new ArrayList<Identity>();

    List<KalendarEvent> lstEvent = new ArrayList<KalendarEvent>();

    lstEvent.add(event);

    BitSet selection = new BitSet(1);

    selection.set(0);

    identities = getSelectedEventParticipants(lstEvent, selection);

    return identities;

  }

 

  /**

   * Generates the mail window

   * @param ureq

   * @param wControl

   * @param listener

   * @param velocity_root

   * @param trans

   * @param participants

   * @return VelocityContainer

   */

  protected VelocityContainer sendParticipantsMessage(UserRequest ureq, WindowControl wControl, DefaultController listener, String velocity_root, Translator trans, List<Identity> participants) {

    VelocityContainer sendMessageVC = new VelocityContainer("sendmessage", velocity_root + "/sendmessage.html", trans, listener);

    ContactMessage cmsg = new ContactMessage(ureq.getIdentity());

    ContactList contactList = null;

    if(participants.size() == 1) {

      contactList = new ContactList(participants.get(0).getUser().getProperty(UserConstants.EMAIL, ureq.getLocale()));

    } else {

      contactList = new ContactList(trans.translate("participants.message.to"));

    }

    contactList.addAllIdentites(participants);

    cmsg.addEmailTo(contactList);

    ContactFormController contactCtr = new ContactFormController(ureq, wControl, false, false, false, false, cmsg);

    contactCtr.addControllerListener(listener);

    sendMessageVC.contextPut("title", trans.translate("participants.message"));

    sendMessageVC.put("contactForm", contactCtr.getInitialComponent());

   

    return sendMessageVC;

  }

 

  /**

   * Generates the duration as string

   * @param event

   * @return String with duration in format "hh:mm"

   */

  protected String getDurationAsString(KalendarEvent event) {

    Date begin = event.getBegin();

    Date end = event.getEnd();

    long duration = end.getTime() - begin.getTime();

    long hours = (long)Math.floor(duration / 1000 / 60 / 60);

    long minutes = (duration / 1000 / 60 % 60);

    StringBuilder sbHours = new StringBuilder();

    StringBuilder sbMinutes = new StringBuilder();

    if(hours < 10)

      sbHours.append(0);

    if(minutes < 10)

      sbMinutes.append(0);

    sbHours.append(hours);

    sbMinutes.append(minutes);

    //in case of failure

    if(sbHours.length() > 2 || sbMinutes.length() > 2)

      return "00:00";

   

    return new String(sbHours + ":" + sbMinutes);

  }

 

  /**

   * Generates a mail template for users who were added to a date

   * @param identity

   * @param event

   * @param translator

   * @return MailTemplate

   */

  protected MailTemplate getAddedMailTemplate(UserRequest ureq, String subjectStr, Translator translator) {

    Identity identity = ureq.getIdentity();

   

    String[] bodyArgs = new String[] {

          identity.getUser().getProperty(UserConstants.FIRSTNAME, ureq.getLocale()),

          identity.getUser().getProperty(UserConstants.LASTNAME, ureq.getLocale()),

          identity.getUser().getProperty(UserConstants.EMAIL, ureq.getLocale()),

          identity.getName(),

          subjectStr

        };

   

    String subject = translator.translate("mail.participants.add.subject", bodyArgs);

    String body = translator.translate("mail.participants.add.body", bodyArgs);

   

    MailTemplate mailTempl = new MailTemplate(subject, body, null) {

      @Override

      public void putVariablesInMailContext(VelocityContext context, Identity identity) {

//        context.put("firstname", user.getProperty(UserConstants.FIRSTNAME, ureq.getLocale()));

//        context.put("lastname", user.getProperty(UserConstants.LASTNAME, ureq.getLocale()));

//        context.put("login", identity.getName());

      }

    };

   

    return mailTempl;

  }

 

  /**

   * Generates a mail template for users who were removed from a date

   * @param identity

   * @param event

   * @param trans

   * @return MailTemplate

   */

  protected MailTemplate getRemovedMailTemplate(UserRequest ureq, String subjectStr, Translator trans) {

    Identity identity = ureq.getIdentity();

   

    String[] bodyArgs = new String[] {

        identity.getUser().getProperty(UserConstants.FIRSTNAME, ureq.getLocale()),

        identity.getUser().getProperty(UserConstants.LASTNAME, ureq.getLocale()),

        identity.getUser().getProperty(UserConstants.EMAIL, ureq.getLocale()),

          identity.getName(),

          subjectStr

        };

   

    String subject = trans.translate("mail.participants.remove.subject", bodyArgs);

    String body = trans.translate("mail.participants.remove.body", bodyArgs);

   

    MailTemplate mailTempl = new MailTemplate(subject, body, null) {

      @Override

      public void putVariablesInMailContext(VelocityContext context, Identity identity) {

//        context.put("firstname", user.getFirstName());

//        context.put("lastname", user.getLastName());

//        context.put("login", identity.getName());

      }

    };

   

    return mailTempl;

  }

 

  /*

   * Helper methods

   */

  private boolean isSubstringInStringArray(String str, String[] strArr) {

    for( String tmpStr : strArr ) {

      if (str.equals(tmpStr)) return true;

    }

    return false;

  }

 

  private void createKalendarEventLinks(ICourse course, DENCourseNode courseNode, KalendarEvent event) {

    List kalendarEventLinks = event.getKalendarEventLinks();

    StringBuilder extLink = new StringBuilder();

    extLink.append(WebappHelper.getContextRoot()).append("/auth/repo/go?rid=");

    RepositoryEntry re = RepositoryManager.getInstance().lookupRepositoryEntry(course, true);

    extLink.append(re.getKey()).append("&amp;par=").append(courseNode.getIdent());

    String iconCssClass = CourseNodeFactory.getInstance().getCourseNodeConfiguration(courseNode.getType()).getIconCSSClass();

    KalendarEventLink link = new KalendarEventLink("COURSE", courseNode.getIdent(), courseNode.getShortTitle(), extLink.toString(), iconCssClass);

    kalendarEventLinks.clear();

    kalendarEventLinks.add(link);

  }

}