/**
   * For a {@link Valid} {@link RemoveAccountFormBackingObject}, remove the current authenticated
   * {@link IScheduleOwner} account. Destroy the current authenticated credentials, and redirect to
   * an appropriate view. If the {@link RemoveAccountFormBackingObject} is not valid, redirect to
   * the schedule view.
   *
   * @see OwnerDao#removeAccount(IScheduleOwner)
   * @param fbo
   * @param result
   * @return
   * @throws NotRegisteredException
   */
  @RequestMapping(method = RequestMethod.POST)
  protected String removeAccount(
      @Valid @ModelAttribute RemoveAccountFormBackingObject fbo, BindingResult result)
      throws NotRegisteredException {
    CalendarAccountUserDetails currentUser =
        (CalendarAccountUserDetails)
            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    IScheduleOwner owner = currentUser.getScheduleOwner();
    if (null == owner) {
      throw new NotRegisteredException("action requires registration");
    }
    if (result.hasErrors()) {
      return "remove-account-form";
    }

    if (fbo.isConfirmed()) {
      if (owner.isReflectSchedule()) {
        AvailableSchedule schedule = this.availableScheduleDao.retrieve(owner);
        this.availableScheduleReflectionService.purgeReflections(
            owner, new Date(), schedule.getScheduleEndTime());
      }
      ownerDao.removeAccount(owner);
      SecurityContextHolder.getContext().setAuthentication(null);
      return "redirect:/accountRemoved.html";
    } else {
      return "redirect:schedule.html";
    }
  }
  /**
   * @param ownerIdentifier
   * @param model
   * @param fbo
   * @param bindingResult
   * @return
   * @throws NotAVisitorException
   * @throws OwnerNotFoundException
   * @throws SchedulingException
   */
  @RequestMapping(method = RequestMethod.POST)
  protected String createAppointment(
      final ModelMap model,
      @PathVariable("ownerIdentifier") final String ownerIdentifier,
      @Valid @ModelAttribute(COMMAND_ATTR_NAME) final CreateAppointmentFormBackingObject fbo,
      BindingResult bindingResult)
      throws NotAVisitorException, OwnerNotFoundException, SchedulingException {
    CalendarAccountUserDetailsImpl currentUser =
        (CalendarAccountUserDetailsImpl)
            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    IScheduleVisitor visitor = currentUser.getScheduleVisitor();

    if (bindingResult.hasErrors()) {
      return "visitor/create-appointment-form";
    }

    IScheduleOwner selectedOwner = null;
    if (StringUtils.isNumeric(ownerIdentifier)) {
      Long ownerId = Long.parseLong(ownerIdentifier);
      selectedOwner = findOwnerForVisitor(visitor, ownerId);
    } else {
      PublicProfile profile = publicProfileDao.locatePublicProfileByKey(ownerIdentifier);
      if (null != profile) {
        selectedOwner = ownerDao.locateOwnerByAvailableId(profile.getOwnerId());
      }
    }

    if (null == selectedOwner) {
      throw new OwnerNotFoundException("no owner found for " + ownerIdentifier);
    }

    validateChosenStartTime(
        selectedOwner.getPreferredVisibleWindow(), fbo.getTargetBlock().getStartTime());

    AvailableBlock finalAppointmentBlock = fbo.getTargetBlock();
    if (fbo.isDoubleLengthAvailable()) {
      // check if selected meeting duration matches meeting durations maxLength
      // if it's greater, then we need to look up the next block in the schedule and attempt to
      // combine
      if (fbo.getSelectedDuration() == fbo.getMeetingDurations().getMaxLength()) {
        finalAppointmentBlock =
            availableScheduleDao.retrieveTargetDoubleLengthBlock(
                selectedOwner, finalAppointmentBlock.getStartTime());
      }
    }
    if (null == finalAppointmentBlock) {
      throw new SchedulingException("requested time is not available");
    }

    VEvent event =
        schedulingAssistantService.scheduleAppointment(
            visitor, selectedOwner, finalAppointmentBlock, fbo.getReason());
    model.put("event", event);
    model.put("owner", selectedOwner);
    model.put("ownerRemindersPreference", selectedOwner.getRemindersPreference());
    return "visitor/create-appointment-success";
  }
  /**
   * @param ownerIdentifier
   * @param weekStart
   * @param visitorUsername
   * @param model
   * @return
   * @throws NotAVisitorException
   * @throws CalendarUserNotFoundException
   */
  @RequestMapping(
      value = "/admin/schedule-debug/{ownerIdentifier}/visitor-conflicts.json",
      method = RequestMethod.GET)
  public View visitorConflicts(
      @PathVariable("ownerIdentifier") long ownerIdentifier,
      @RequestParam(value = "weekStart", required = false, defaultValue = "1") int weekStart,
      @RequestParam(value = "visitorUsername", required = true) String visitorUsername,
      final ModelMap model)
      throws NotAVisitorException, CalendarAccountNotFoundException {

    ICalendarAccount visitorAccount = this.calendarAccountDao.getCalendarAccount(visitorUsername);
    if (visitorAccount == null) {
      throw new NotAVisitorException(visitorUsername + " not found");
    }
    IScheduleVisitor visitor = this.visitorDao.toVisitor(visitorAccount);

    IScheduleOwner owner = ownerDao.locateOwnerByAvailableId(ownerIdentifier);
    if (owner == null) {
      throw new CalendarAccountNotFoundException("no owner found for id " + ownerIdentifier);
    }
    VisibleScheduleRequestConstraints requestConstraints =
        VisibleScheduleRequestConstraints.newInstance(owner, weekStart);

    List<AvailableBlock> visitorConflicts =
        this.schedulingAssistantService.calculateVisitorConflicts(
            visitor,
            owner,
            requestConstraints.getTargetStartDate(),
            requestConstraints.getTargetEndDate());
    List<String> conflictBlocks = new ArrayList<String>();
    SimpleDateFormat df = CommonDateOperations.getDateTimeFormat();
    for (AvailableBlock b : visitorConflicts) {
      conflictBlocks.add(df.format(b.getStartTime()));
    }
    model.addAttribute("conflicts", conflictBlocks);

    Calendar visitorCalendar =
        this.calendarDataDao.getCalendar(
            visitorAccount,
            requestConstraints.getTargetStartDate(),
            requestConstraints.getTargetEndDate());
    model.addAttribute("visitorCalendarData", visitorCalendar.toString());
    return new MappingJacksonJsonView();
  }
Example #4
0
  /**
   * @param visitorUsername
   * @param ownerUsername
   * @param startDate
   * @param endDate
   * @return
   * @throws CalendarAccountNotFoundException
   * @throws NotAVisitorException
   * @throws SchedulingException
   */
  public VEvent createAvailableAppointment(
      String visitorUsername, String ownerUsername, Date startDate, Date endDate)
      throws CalendarAccountNotFoundException, NotAVisitorException, SchedulingException {
    ICalendarAccount visitorUser = calendarAccountDao.getCalendarAccount(visitorUsername);
    ICalendarAccount ownerUser = calendarAccountDao.getCalendarAccount(ownerUsername);

    IScheduleVisitor visitor = visitorDao.toVisitor(visitorUser);
    IScheduleOwner owner = ownerDao.locateOwner(ownerUser);
    if (null == owner) {
      throw new SchedulingException("owner not registered with Available");
    }

    AvailableBlock block = availableScheduleDao.retrieveTargetBlock(owner, startDate);
    if (null == block) {
      throw new SchedulingException("owner does not have availability at " + startDate);
    }
    VEvent result =
        this.schedulingAssistantService.scheduleAppointment(
            visitor, owner, block, "test appointment created by WiscCal administrator");
    return result;
  }
  /**
   * @param ownerId
   * @param highContrast
   * @param visitorUsername
   * @return
   * @throws NotAVisitorException
   * @throws CalendarUserNotFoundException
   */
  @RequestMapping(
      value = "/admin/schedule-debug/{ownerIdentifier}/view.html",
      method = RequestMethod.GET)
  public String displaySchedule(
      @PathVariable("ownerIdentifier") long ownerIdentifier,
      @RequestParam(value = "highContrast", required = false, defaultValue = "false")
          boolean highContrast,
      @RequestParam(value = "weekStart", required = false, defaultValue = "0") int weekStart,
      @RequestParam(value = "visitorUsername", required = true) String visitorUsername,
      ModelMap model)
      throws NotAVisitorException, CalendarAccountNotFoundException {

    ICalendarAccount visitorAccount = this.calendarAccountDao.getCalendarAccount(visitorUsername);
    if (visitorAccount == null) {
      throw new NotAVisitorException(visitorUsername + " not found");
    }
    IScheduleVisitor visitor = this.visitorDao.toVisitor(visitorAccount);
    model.addAttribute("visitor", visitor);
    IScheduleOwner selectedOwner = ownerDao.locateOwnerByAvailableId(ownerIdentifier);
    if (selectedOwner == null) {
      throw new CalendarAccountNotFoundException("no owner found for id " + ownerIdentifier);
    }
    VisibleScheduleRequestConstraints requestConstraints =
        VisibleScheduleRequestConstraints.newInstance(selectedOwner, weekStart);
    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "displaySchedule request, visitor: "
              + visitor
              + "; weekStart: "
              + weekStart
              + "requestConstraints "
              + requestConstraints);
    }

    Calendar ownerCalendar =
        this.calendarDataDao.getCalendar(
            selectedOwner.getCalendarAccount(),
            requestConstraints.getTargetStartDate(),
            requestConstraints.getTargetEndDate());
    model.addAttribute("ownerCalendarData", ownerCalendar.toString());
    model.addAttribute("noteboard", selectedOwner.getPreference(Preferences.NOTEBOARD));
    model.addAttribute("owner", selectedOwner);
    model.addAttribute("highContrast", highContrast);

    VisibleSchedule schedule;

    if (selectedOwner.hasMeetingLimit()) {
      // we have to look at the whole visible schedule for attendings
      schedule = schedulingAssistantService.getVisibleSchedule(visitor, selectedOwner);
      if (selectedOwner.isExceedingMeetingLimit(schedule.getAttendingCount())) {
        // return attending only view
        List<AvailableBlock> attendingList = schedule.getAttendingList();
        model.addAttribute("attendingList", attendingList);
        return "admin/debug-already-attending";
      } else {
        // extract start->end from visibleSchedule
        schedule =
            schedule.subset(
                requestConstraints.getTargetStartDate(), requestConstraints.getTargetEndDate());
      }

    } else {
      // only pull start->end of schedule
      schedule =
          schedulingAssistantService.getVisibleSchedule(
              visitor,
              selectedOwner,
              requestConstraints.getTargetStartDate(),
              requestConstraints.getTargetEndDate());
    }

    model.addAttribute("visibleSchedule", schedule);
    model.addAttribute("scheduleStart", schedule.getScheduleStart());
    model.addAttribute("prevWeekStart", requestConstraints.getPrevWeekIndex());
    model.addAttribute("nextWeekStart", requestConstraints.getNextWeekIndex());
    model.addAttribute("weekStart", requestConstraints.getConstrainedWeekStart());
    model.addAttribute("ownerVisitorSamePerson", selectedOwner.isSamePerson(visitor));
    return "admin/debug-visible-schedule";
  }
  /**
   * @param model
   * @param startTimePhrase
   * @param ownerId
   * @return
   * @throws InputFormatException
   * @throws SchedulingException
   * @throws OwnerNotFoundException
   * @throws NotAVisitorException
   */
  @RequestMapping(method = RequestMethod.GET)
  protected String setupForm(
      final ModelMap model,
      @RequestParam(value = "startTime", required = true) final String startTimePhrase,
      @PathVariable("ownerIdentifier") final String ownerIdentifier)
      throws InputFormatException, SchedulingException, OwnerNotFoundException,
          NotAVisitorException {
    CalendarAccountUserDetailsImpl currentUser =
        (CalendarAccountUserDetailsImpl)
            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    IScheduleVisitor visitor = currentUser.getScheduleVisitor();

    IScheduleOwner selectedOwner = null;
    if (StringUtils.isNumeric(ownerIdentifier)) {
      Long ownerId = Long.parseLong(ownerIdentifier);
      selectedOwner = findOwnerForVisitor(visitor, ownerId);
    } else {
      PublicProfile profile = publicProfileDao.locatePublicProfileByKey(ownerIdentifier);
      if (null != profile) {
        selectedOwner = ownerDao.locateOwnerByAvailableId(profile.getOwnerId());
      }
    }

    if (null == selectedOwner) {
      throw new OwnerNotFoundException("no owner found for " + ownerIdentifier);
    }
    model.put("owner", selectedOwner);
    Date startTime = CommonDateOperations.parseDateTimePhrase(startTimePhrase);
    validateChosenStartTime(selectedOwner.getPreferredVisibleWindow(), startTime);

    AvailableBlock targetBlock = availableScheduleDao.retrieveTargetBlock(selectedOwner, startTime);
    if (null == targetBlock) {
      throw new SchedulingException("requested time is not available");
    }

    if (selectedOwner.hasMeetingLimit()) {
      VisibleSchedule sched = schedulingAssistantService.getVisibleSchedule(visitor, selectedOwner);
      int attendingCount = sched.getAttendingCount();
      if (selectedOwner.isExceedingMeetingLimit(attendingCount)) {
        // visitor has already matched owner's appointment limit
        LOG.warn(
            "blocked attempt to use create form by visitor: "
                + visitor
                + ", target owner: "
                + selectedOwner);
        return "redirect:view.html";
      }
    }

    VEvent event = schedulingAssistantService.getExistingAppointment(targetBlock, selectedOwner);
    if (event != null) {
      model.put("event", event);
      if (this.eventUtils.isAttendingAsVisitor(event, visitor.getCalendarAccount())) {
        // redirect the visitor to the cancel form
        StringBuilder redirect = new StringBuilder("redirect:cancel.html?r=true&startTime=");
        SimpleDateFormat dateFormat = CommonDateOperations.getDateTimeFormat();
        redirect.append(startTimePhrase);
        redirect.append("&endTime=");
        redirect.append(dateFormat.format(targetBlock.getEndTime()));
        return redirect.toString();
      }

      Integer visitorLimit = this.eventUtils.getEventVisitorLimit(event);
      model.put("visitorLimit", visitorLimit);
      if (this.eventUtils.getScheduleVisitorCount(event) >= visitorLimit) {
        return "visitor/appointment-full";
      }
    }
    CreateAppointmentFormBackingObject fbo =
        new CreateAppointmentFormBackingObject(
            targetBlock, selectedOwner.getPreferredMeetingDurations());
    model.addAttribute(COMMAND_ATTR_NAME, fbo);
    return "visitor/create-appointment-form";
  }