Java tutorial
/* * Copyright 2011 The Kuali Foundation * * Licensed under the Educational Community License, Version 1.0 (the * "License"); you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.opensource.org/licenses/ecl1.php * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package org.kuali.student.enrollment.class2.acal.controller; import org.apache.commons.lang.BooleanUtils; import org.apache.commons.lang.StringUtils; import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader; import org.kuali.rice.core.api.util.RiceKeyConstants; import org.kuali.rice.krad.uif.UifParameters; import org.kuali.rice.krad.uif.view.DialogManager; import org.kuali.rice.krad.util.GlobalVariables; import org.kuali.rice.krad.util.KRADConstants; import org.kuali.rice.krad.web.controller.MethodAccessible; import org.kuali.rice.krad.web.controller.UifControllerBase; import org.kuali.rice.krad.web.form.UifFormBase; import org.kuali.student.common.uif.util.KSControllerHelper; import org.kuali.student.common.uif.util.KSUifUtils; import org.kuali.student.enrollment.class2.acal.dto.AcademicTermWrapper; import org.kuali.student.enrollment.class2.acal.dto.AcalEventWrapper; import org.kuali.student.enrollment.class2.acal.dto.ExamPeriodWrapper; import org.kuali.student.enrollment.class2.acal.dto.HolidayCalendarWrapper; import org.kuali.student.enrollment.class2.acal.dto.KeyDateWrapper; import org.kuali.student.enrollment.class2.acal.dto.KeyDatesGroupWrapper; import org.kuali.student.enrollment.class2.acal.form.AcademicCalendarForm; import org.kuali.student.enrollment.class2.acal.service.AcademicCalendarViewHelperService; import org.kuali.student.enrollment.class2.acal.util.CalendarConstants; import org.kuali.student.enrollment.class2.acal.util.AcalCommonUtils; import org.kuali.student.r2.common.dto.AttributeInfo; import org.kuali.student.r2.common.dto.RichTextInfo; import org.kuali.student.r2.common.dto.StatusInfo; import org.kuali.student.r2.common.exceptions.OperationFailedException; import org.kuali.student.r2.common.exceptions.VersionMismatchException; import org.kuali.student.r2.core.acal.dto.AcademicCalendarInfo; import org.kuali.student.r2.core.acal.dto.AcalEventInfo; import org.kuali.student.r2.core.acal.dto.ExamPeriodInfo; import org.kuali.student.r2.core.acal.dto.KeyDateInfo; import org.kuali.student.r2.core.acal.dto.TermInfo; import org.kuali.student.r2.core.acal.service.AcademicCalendarService; import org.kuali.student.r2.core.acal.service.facade.AcademicCalendarServiceFacade; import org.kuali.student.r2.core.constants.AcademicCalendarServiceConstants; import org.kuali.student.r2.core.constants.AtpServiceConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Controller; import org.springframework.validation.BindingResult; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.xml.namespace.QName; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Properties; /** * This controller handles all the request from Academic calendar UI. * * These are the related xmls from where requests come to this controller * 1. AcademicCalendarView.xml * 2. AcademicCalendarEditPage.xml * 3. AcademicCalendarCopyPage.xml * 4. AcademicTermPage.xml * * @author Kuali Student Team */ @Controller @RequestMapping(value = "/academicCalendar") public class AcademicCalendarController extends UifControllerBase { private static final Logger LOG = LoggerFactory.getLogger(AcademicCalendarController.class); private AcademicCalendarService acalService; private AcademicCalendarServiceFacade academicCalendarServiceFacade; protected static Logger getLog() { return LOG; } @Override protected UifFormBase createInitialForm(HttpServletRequest request) { return new AcademicCalendarForm(); } /** * This method loads an academic calendar based on the parameters passed into the request. * * These are the supported request parameters (specific to Acal) * 1. id - Academic Calendar Id to load in to UI * 2. readOnlyView - If true, sets the view as read only * 3. selectTab - can be 'info' or 'term' * */ @Override @RequestMapping(method = RequestMethod.GET, params = "methodToCall=start") public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, HttpServletRequest request, HttpServletResponse response) { AcademicCalendarForm acalForm = (AcademicCalendarForm) form; String acalId = request.getParameter(CalendarConstants.CALENDAR_ID); if (StringUtils.isNotBlank(acalId)) { getAcalViewHelperService(acalForm).populateAcademicCalendar(acalId, acalForm); } String readOnlyView = request.getParameter(CalendarConstants.READ_ONLY_VIEW); acalForm.getView().setReadOnly(BooleanUtils.toBoolean(readOnlyView)); if (StringUtils.isNotBlank(request.getParameter(CalendarConstants.SELECT_TAB))) { acalForm.setDefaultTabToShow(request.getParameter(CalendarConstants.SELECT_TAB)); } return getUIFModelAndView(form); } @RequestMapping(method = RequestMethod.POST, params = "methodToCall=reload") public ModelAndView reload(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String acalId = acalForm.getAcademicCalendarInfo().getId(); getAcalViewHelperService(acalForm).populateAcademicCalendar(acalId, acalForm); acalForm.setReload(false); return getUIFModelAndView(acalForm, CalendarConstants.ACADEMIC_CALENDAR_EDIT_PAGE); } /** * This method creates a blank academic calendar. */ @RequestMapping(params = "methodToCall=createBlankCalendar") public ModelAndView createBlankCalendar(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { Properties urlParameters = new Properties(); urlParameters.put(UifParameters.VIEW_ID, CalendarConstants.ACAL_VIEW); String flowKey = acalForm.getFlowKey(); urlParameters.put("flow", flowKey == null ? "" : flowKey); urlParameters.put(CalendarConstants.PAGE_ID, CalendarConstants.ACADEMIC_CALENDAR_EDIT_PAGE); urlParameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, "startNew"); String controllerPath = CalendarConstants.ACAL_CONTROLLER_PATH; return super.performRedirect(acalForm, controllerPath, urlParameters); } /** * KSENROLL-12648: workaround for rice 2.4 upgrade issue * This method takes request params to construct key date wrapper from add blank line * and add it to the collection */ @MethodAccessible @RequestMapping(params = "methodToCall=addKeyDateWrapperToForm") public void addKeyDateWrapperToForm(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String termIndex = request.getParameter("termIndex"); String keyDateGroupIndex = request.getParameter("keyDateGroupIndex"); String keyDateIndex = request.getParameter("keyDateIndex"); KeyDateWrapper keyDateWrapper = new KeyDateWrapper(); acalForm.getTermWrapperList().get(Integer.parseInt(termIndex)).getKeyDatesGroupWrappers() .get(Integer.parseInt(keyDateGroupIndex)).getKeydates().add(keyDateWrapper); } /** * KSENROLL-12648: workaround for rice 2.4 upgrade issue * This method takes request params to construct key date wrapper from add blank line * and add it to the collection */ @MethodAccessible @RequestMapping(params = "methodToCall=processBlankLineKeyDate") public void processBlankLineKeyDate(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { DateFormat df = new SimpleDateFormat("MM/dd/yyyy"); String termIndex = request.getParameter("termIndex"); String keyDateGroupIndex = request.getParameter("keyDateGroupIndex"); String keyDateIndex = request.getParameter("keyDateIndex"); KeyDateWrapper keyDateWrapper = new KeyDateWrapper(); keyDateWrapper.setKeyDateType(request.getParameter("keyDateType")); keyDateWrapper.setStartTime(request.getParameter("keyDateStartTime")); keyDateWrapper.setStartTimeAmPm(request.getParameter("keyDateStartTimeAmPm")); keyDateWrapper.setEndTime(request.getParameter("keyDateEndTime")); keyDateWrapper.setEndTimeAmPm(request.getParameter("keyDateEndTimeAmPm")); if (StringUtils.isNotBlank(request.getParameter("keyDateStartDate"))) { try { keyDateWrapper.setStartDate(df.parse(request.getParameter("keyDateStartDate"))); } catch (Exception e) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(e); } } if (StringUtils.isNotBlank(request.getParameter("keyDateEndDate"))) { try { keyDateWrapper.setEndDate(df.parse(request.getParameter("keyDateEndDate"))); } catch (Exception e) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(e); } } acalForm.getTermWrapperList().get(Integer.parseInt(termIndex)).getKeyDatesGroupWrappers() .get(Integer.parseInt(keyDateGroupIndex)).getKeydates() .set(Integer.parseInt(keyDateIndex), keyDateWrapper); } /** * This method is called before the Create New Academic Calendar page is displayed * * It fills in the original Acal for the form with the latest calendar found, by default */ @MethodAccessible @RequestMapping(method = RequestMethod.GET, params = "methodToCall=startNew") public ModelAndView startNew(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { try { AcademicCalendarInfo acalInfo = getAcalViewHelperService(acalForm).getLatestAcademicCalendar(); acalForm.setCopyFromAcal(acalInfo); acalForm.setMeta(acalInfo.getMeta()); } catch (Exception e) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(e); } return super.start(acalForm, request, response); } /** * This method will be called when user clicks on the edit link at the header portion of acal. * * @param acalForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=toEdit") public ModelAndView toEdit(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { AcademicCalendarInfo acalInfo = acalForm.getAcademicCalendarInfo(); AcademicCalendarInfo orgAcalInfo = acalForm.getCopyFromAcal(); if (StringUtils.isBlank(acalInfo.getId()) && StringUtils.isNotBlank(orgAcalInfo.getId())) { getAcalViewHelperService(acalForm).populateAcademicCalendar(orgAcalInfo.getId(), acalForm); acalForm.setCopyFromAcal(new AcademicCalendarInfo()); } acalForm.getView().setReadOnly(false); return getUIFModelAndView(acalForm, CalendarConstants.ACADEMIC_CALENDAR_EDIT_PAGE); } /** * Passes on request from Acal view to copy the Acal to the copyForNew method. Needed a forwarder here because the * call is a GET rather than a POST * * @param acalForm * @param result * @param request * @param response * @return */ @MethodAccessible @RequestMapping(params = "methodToCall=toCopy") public ModelAndView toCopy(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { AcademicCalendarInfo acalInfo = null; String acalId = request.getParameter(CalendarConstants.CALENDAR_ID); if (acalId != null && !acalId.trim().isEmpty()) { String pageId = request.getParameter(CalendarConstants.PAGE_ID); if (CalendarConstants.ACADEMIC_CALENDAR_COPY_PAGE.equals(pageId)) { try { acalInfo = getAcalService().getAcademicCalendar(acalId, getAcalViewHelperService(acalForm).createContextInfo()); acalForm.setCopyFromAcal(acalInfo); } catch (Exception ex) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(ex); } } } else { // try to get the AC from the form (in case of copy from the Acal view page) and set it as the Original Acal try { acalInfo = acalForm.getAcademicCalendarInfo(); acalForm.reset(); acalForm.setNewCalendar(true); acalForm.setCopyFromAcal(acalInfo); } catch (Exception e) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(e); } } // Anything that extends KSUIFForm.java will have meta information if (acalInfo != null) { acalForm.setMeta(acalInfo.getMeta()); } return copy(acalForm, result, request, response); } /** * Copy over from the existing AcalInfo to create a new. * * @param acalForm * @param result * @param request * @param response * @return */ @RequestMapping(method = RequestMethod.POST, params = "methodToCall=copy") public ModelAndView copy(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { getAcalViewHelperService(acalForm).copyToCreateAcademicCalendar(acalForm); return getUIFModelAndView(acalForm, CalendarConstants.ACADEMIC_CALENDAR_EDIT_PAGE); } //Editing Hcal is implemented fully and it's working.. but we're having some issues with KRAD form management //This will be implemented in future milestones /*@RequestMapping(method = RequestMethod.POST, params="methodToCall=editHolidayCalendar") public ModelAndView editHolidayCalendar( @ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String selectedCollectionPath = acalForm.getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = -1; String selectedLine = acalForm.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX); if (StringUtils.isNotBlank(selectedLine)) { selectedLineIndex = Integer.parseInt(selectedLine); } if (selectedLineIndex == -1) { throw new RuntimeException("unable to determine the selected line index"); } Properties hcalURLParam = new Properties(); hcalURLParam.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, CalendarConstants.HC_EDIT_METHOD); hcalURLParam.put(CalendarConstants.CALENDAR_ID, acalForm.getHolidayCalendarList().get(selectedLineIndex).getId()); hcalURLParam.put(UifParameters.VIEW_ID, CalendarConstants.HOLIDAYCALENDAR_FLOWVIEW); hcalURLParam.put(UifParameters.PAGE_ID, CalendarConstants.HOLIDAYCALENDAR_EDITPAGE); hcalURLParam.put(UifParameters.RETURN_FORM_KEY, acalForm.getFormKey()); Properties acalReturnURLParams = new Properties(); acalReturnURLParams.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, CalendarConstants.AC_EDIT_METHOD); acalReturnURLParams.put(UifParameters.VIEW_ID, CalendarConstants.ACAL_VIEW); acalReturnURLParams.put(UifParameters.PAGE_ID, CalendarConstants.ACADEMIC_CALENDAR_EDIT_PAGE); String returnUrl = UrlFactory.parameterizeUrl(CalendarConstants.ACAL_CONTROLLER_PATH, acalReturnURLParams); hcalURLParam.put(UifParameters.RETURN_LOCATION, returnUrl); return super.performRedirect(acalForm,CalendarConstants.HCAL_CONTROLLER_PATH, hcalURLParam); }*/ /** * Redirects the user to the search Calendar page * * @param acalForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=search") public ModelAndView search(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String controllerPath = CalendarConstants.CALENDAR_SEARCH_CONTROLLER_PATH; Properties urlParameters = new Properties(); urlParameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, KRADConstants.START_METHOD); urlParameters.put(UifParameters.VIEW_ID, CalendarConstants.CALENDAR_SEARCH_VIEW); return super.performRedirect(acalForm, controllerPath, urlParameters); } /** * This will save the academic calendar and terms. Uses dialog confirmations to verify changes from draft to * offical state. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=save") public ModelAndView save(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { AcademicCalendarForm acal = saveAcademicCalendarDirtyFields(academicCalendarForm); return getUIFModelAndView(acal); } /** * Method used to delete AcademicCalendar * * @param acalForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=delete") public ModelAndView delete(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String dialog = CalendarConstants.ACADEMIC_DELETE_CONFIRMATION_DIALOG; if (!hasDialogBeenDisplayed(dialog, acalForm)) { //redirect back to client to display lightbox return showDialog(dialog, acalForm, request, response); } else { if (hasDialogBeenAnswered(dialog, acalForm)) { boolean confirmDelete = getBooleanDialogResponse(dialog, acalForm, request, response); acalForm.getDialogManager().resetDialogStatus(dialog); if (!confirmDelete) { return getUIFModelAndView(acalForm); } } else { //redirect back to client to display lightbox return showDialog(dialog, acalForm, request, response); } } StatusInfo statusInfo; try { statusInfo = getAcademicCalendarServiceFacade().deleteCalendarCascaded( acalForm.getAcademicCalendarInfo().getId(), getAcalViewHelperService(acalForm).createContextInfo()); } catch (Exception e) { throw getAcalViewHelperService(acalForm).convertServiceExceptionsToUI(e); } if (statusInfo.getIsSuccess()) { // If delete successful, populate growl message parameters and redirect to the search page. String[] parameters = { acalForm.getAcademicCalendarInfo().getName() }; KSUifUtils.getMessengerFromUserSession() .addSuccessMessage(CalendarConstants.MessageKeys.INFO_ACADEMIC_CALENDAR_DELETED, parameters); Properties urlParameters = new Properties(); return redirectToSearch(acalForm, request, urlParameters); } else { GlobalVariables.getMessageMap().putInfo(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_DELETING, acalForm.getAcademicCalendarInfo().getName(), statusInfo.getMessage()); return getUIFModelAndView(acalForm); } } /** * Cancel editing a term. This will undo all the changes done by the users. Basically, it loads the term info * from the DB. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(method = RequestMethod.POST, params = "methodToCall=cancelTerm") public ModelAndView cancelTerm(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); AcademicTermWrapper termWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); AcademicCalendarViewHelperService viewHelperService = getAcalViewHelperService(academicCalendarForm); if (termWrapper.isNew()) { academicCalendarForm.getTermWrapperList().remove(selectedLineIndex); if (termWrapper.isHasSubterm()) { List<AcademicTermWrapper> subTerms = termWrapper.getSubterms(); for (AcademicTermWrapper subTerm : subTerms) { academicCalendarForm.getTermWrapperList().remove(subTerm); } } } else { //this part will not be called since cancel Term link does not show up after a term is persisted in DB. try { TermInfo termInfo = getAcalService().getTerm(termWrapper.getTermInfo().getId(), viewHelperService.createContextInfo()); boolean calculateInstrDays = !academicCalendarForm.getHolidayCalendarList().isEmpty(); AcademicTermWrapper termWrapperFromDB = viewHelperService.populateTermWrapper(termInfo, false, calculateInstrDays); academicCalendarForm.getTermWrapperList().set(selectedLineIndex, termWrapperFromDB); } catch (Exception e) { throw getAcalViewHelperService(academicCalendarForm).convertServiceExceptionsToUI(e); } } return getUIFModelAndView(academicCalendarForm); } /** * This method makes a term official and persist to DB. User can selectively make a term official. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=makeTermOfficial") public ModelAndView makeTermOfficial(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); int selectedLineIndex; AcademicTermWrapper termWrapper; String dialog = null; if (academicCalendarForm.isOfficialCalendar()) { dialog = CalendarConstants.ACADEMIC_TERM_OFFICIAL_CONFIRMATION_DIALOG; } else { dialog = CalendarConstants.ACADEMIC_TERM_AND_CALENDAR_OFFICIAL_CONFIRMATION_DIALOG; } // Dialog confirmation to make terms official if (!hasDialogBeenDisplayed(dialog, academicCalendarForm)) { selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); termWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); academicCalendarForm.setSelectedCollectionPath( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH)); academicCalendarForm.setSelectedLineIndex( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX)); academicCalendarForm.setMakeOfficialName(termWrapper.getName()); academicCalendarForm.setMakeOfficialIsSubterm(termWrapper.isSubTerm()); if (termWrapper.getParentTermInfo() != null) { academicCalendarForm.setMakeOfficialParentTermName(termWrapper.getParentTermInfo().getName()); academicCalendarForm.setOfficialParentTerm(false); for (AcademicTermWrapper term : academicCalendarForm.getTermWrapperList()) { if (term.getTermInfo().getId().equals(termWrapper.getParentTermInfo().getId())) { academicCalendarForm.setOfficialParentTerm(term.isOfficial()); } } } //redirect back to client to display lightbox return showDialog(dialog, academicCalendarForm, request, response); } else { if (hasDialogBeenAnswered(dialog, academicCalendarForm)) { boolean confirm = getBooleanDialogResponse(dialog, academicCalendarForm, request, response); academicCalendarForm.getDialogManager().resetDialogStatus(dialog); if (!confirm) { return getUIFModelAndView(academicCalendarForm); } } else { selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); termWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); academicCalendarForm.setSelectedCollectionPath( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH)); academicCalendarForm.setSelectedLineIndex( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX)); academicCalendarForm.setMakeOfficialName(termWrapper.getName()); academicCalendarForm.setMakeOfficialIsSubterm(termWrapper.isSubTerm()); if (termWrapper.getParentTermInfo() != null) { academicCalendarForm.setMakeOfficialParentTermName(termWrapper.getParentTermInfo().getName()); academicCalendarForm.setOfficialParentTerm(false); for (AcademicTermWrapper term : academicCalendarForm.getTermWrapperList()) { if (term.getTermInfo().getId().equals(termWrapper.getParentTermInfo().getId())) { academicCalendarForm.setOfficialParentTerm(term.isOfficial()); } } } //redirect back to client to display lightbox return showDialog(dialog, academicCalendarForm, request, response); } } academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_COLLECTION_PATH, academicCalendarForm.getSelectedCollectionPath()); if (academicCalendarForm.getSelectedLineIndex() != null && academicCalendarForm.getSelectedLineIndex().indexOf(",") > -1) { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm .getSelectedLineIndex().substring(0, academicCalendarForm.getSelectedLineIndex().indexOf(","))); } else { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm.getSelectedLineIndex()); } selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); termWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); boolean acalOfficial = true; if (!academicCalendarForm.isOfficialCalendar()) { acalOfficial = makeAcalOfficial(academicCalendarForm); } if (acalOfficial) { makeTermOfficial(termWrapper, academicCalendarForm); } getAcalViewHelperService(academicCalendarForm).populateAcademicCalendar( academicCalendarForm.getAcademicCalendarInfo().getId(), academicCalendarForm); academicCalendarForm.setDefaultTabToShow(CalendarConstants.ACAL_TERM_TAB); return getUIFModelAndView(academicCalendarForm); } /** * * Improvement jira KSENROLL-3568 to clear all the fields at the client side instead of at server side. * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(method = RequestMethod.POST, params = "methodToCall=cancelAddingHoliday") public ModelAndView cancelAddingHoliday(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); ((HolidayCalendarWrapper) academicCalendarForm.getNewCollectionLines().get("holidayCalendarList")) .setId(StringUtils.EMPTY); return getUIFModelAndView(academicCalendarForm); } protected void setDeleteTermMessageWithContext(AcademicCalendarForm academicCalendarForm) { academicCalendarForm.setSelectedCollectionPath( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH)); academicCalendarForm.setSelectedLineIndex( academicCalendarForm.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX)); academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_COLLECTION_PATH, academicCalendarForm.getSelectedCollectionPath()); if (academicCalendarForm.getSelectedLineIndex() != null && academicCalendarForm.getSelectedLineIndex().indexOf(",") > -1) { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm .getSelectedLineIndex().substring(0, academicCalendarForm.getSelectedLineIndex().indexOf(","))); } else { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm.getSelectedLineIndex()); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); AcademicTermWrapper selectedTermWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); if (selectedTermWrapper.isSubTerm()) { academicCalendarForm .setMessageForDeleteTermOrSubterm(CalendarConstants.MESSAGE_CONFIRM_TO_DELETE_SUBTERM); } else if (selectedTermWrapper.isHasSubterm()) { academicCalendarForm.setMessageForDeleteTermOrSubterm( CalendarConstants.MESSAGE_CONFIRM_TO_DELETE_TERM_WITH_SUBTERM); } else { academicCalendarForm .setMessageForDeleteTermOrSubterm(CalendarConstants.MESSAGE_CONFIRM_TO_DELETE_TERM_ONLY); } } /** * This would mark a term for deletion if it's already there in the DB. If it's a newly added term, it just deletes * that. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=deleteTerm") public ModelAndView deleteTerm(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String dialog = CalendarConstants.TERM_DELETE_CONFIRMATION_DIALOG; if (!hasDialogBeenDisplayed(dialog, academicCalendarForm)) { setDeleteTermMessageWithContext(academicCalendarForm); //redirect back to client to display lightbox return showDialog(dialog, academicCalendarForm, request, response); } else { if (hasDialogBeenAnswered(dialog, academicCalendarForm)) { boolean confirmDelete = getBooleanDialogResponse(dialog, academicCalendarForm, request, response); academicCalendarForm.getDialogManager().resetDialogStatus(dialog); if (!confirmDelete) { return getUIFModelAndView(academicCalendarForm); } } else { setDeleteTermMessageWithContext(academicCalendarForm); //redirect back to client to display lightbox return showDialog(dialog, academicCalendarForm, request, response); } } academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_COLLECTION_PATH, academicCalendarForm.getSelectedCollectionPath()); if (academicCalendarForm.getSelectedLineIndex() != null && academicCalendarForm.getSelectedLineIndex().indexOf(",") > -1) { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm .getSelectedLineIndex().substring(0, academicCalendarForm.getSelectedLineIndex().indexOf(","))); } else { academicCalendarForm.getActionParameters().put(UifParameters.SELECTED_LINE_INDEX, academicCalendarForm.getSelectedLineIndex()); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); AcademicTermWrapper theTermWrapper = academicCalendarForm.getTermWrapperList().get(selectedLineIndex); if (!theTermWrapper.isNew()) { academicCalendarForm.getTermsToDeleteOnSave().add(theTermWrapper); } academicCalendarForm.getTermWrapperList().remove(selectedLineIndex); if (theTermWrapper.isHasSubterm()) { //get all subterms and remove them as well List<AcademicTermWrapper> subTerms = theTermWrapper.getSubterms(); for (AcademicTermWrapper subTerm : subTerms) { academicCalendarForm.getTermWrapperList().remove(subTerm); } } return getUIFModelAndView(academicCalendarForm); } /** * Like term, this would mark a key date for deletion. If it's newly added, just deletes it. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(method = RequestMethod.POST, params = "methodToCall=deleteKeyDate") public ModelAndView deleteKeyDate(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String selectedCollectionPath = academicCalendarForm .getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); String selectedTermIndex = StringUtils.substringBetween(selectedCollectionPath, "termWrapperList[", "]"); String selectedKeyDateGroup = StringUtils.substringBetween(selectedCollectionPath, "keyDatesGroupWrappers[", "]"); AcademicTermWrapper termWrapper = academicCalendarForm.getTermWrapperList() .get(Integer.parseInt(selectedTermIndex)); KeyDatesGroupWrapper keydateGroup = termWrapper.getKeyDatesGroupWrappers() .get(Integer.parseInt(selectedKeyDateGroup)); KeyDateWrapper keyDateWrapper = keydateGroup.getKeydates().get(selectedLineIndex); if (StringUtils.isNotBlank(keyDateWrapper.getKeyDateInfo().getId())) { termWrapper.getKeyDatesToDeleteOnSave().add(keyDateWrapper); } keydateGroup.getKeydates().remove(selectedLineIndex); academicCalendarForm.getAddedCollectionItems().remove(keyDateWrapper); return getUIFModelAndView(academicCalendarForm); } /** * Like term, this would mark an exam period for deletion. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(method = RequestMethod.POST, params = "methodToCall=markExamPeriodtoDelete") public ModelAndView markExamPeriodtoDelete( @ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String selectedCollectionPath = academicCalendarForm .getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); String selectedTermIndex = StringUtils.substringBetween(selectedCollectionPath, "termWrapperList[", "]"); AcademicTermWrapper termWrapper = academicCalendarForm.getTermWrapperList() .get(Integer.parseInt(selectedTermIndex)); ExamPeriodWrapper examPeriodWrapper = termWrapper.getExamdates().get(selectedLineIndex); if (StringUtils.isNotBlank(examPeriodWrapper.getExamPeriodInfo().getId())) { termWrapper.getExamPeriodsToDeleteOnSave().add(examPeriodWrapper); } termWrapper.getExamdates().remove(selectedLineIndex); return getUIFModelAndView(academicCalendarForm); } @RequestMapping(params = "methodToCall=deleteKeyDateGroup") public ModelAndView deleteKeyDateGroup(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String selectedCollectionPath = academicCalendarForm .getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); String selectedTermIndex = StringUtils.substringBetween(selectedCollectionPath, "termWrapperList[", "]"); AcademicTermWrapper termWrapper = academicCalendarForm.getTermWrapperList() .get(Integer.parseInt(selectedTermIndex)); KeyDatesGroupWrapper keydateGroup = termWrapper.getKeyDatesGroupWrappers().get(selectedLineIndex); for (KeyDateWrapper keyDateWrapper : keydateGroup.getKeydates()) { if (StringUtils.isNotBlank(keyDateWrapper.getKeyDateInfo().getId())) { termWrapper.getKeyDatesToDeleteOnSave().add(keyDateWrapper); } } termWrapper.getKeyDatesGroupWrappers().remove(keydateGroup); return getUIFModelAndView(academicCalendarForm); } /** * Removes the the selected holiday for delete from the list of holidays. * No changes are made to database until save. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=deleteHolidayCalendar") public ModelAndView deleteHolidayCalendar( @ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String selectedCollectionPath = academicCalendarForm .getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); academicCalendarForm.getHolidayCalendarList().remove(selectedLineIndex); return getUIFModelAndView(academicCalendarForm); } /** * Removes the the selected event for delete from the list of events. * Event is added to the list of events to be deleted during save if it is in the database. * No changes are made to database until save. * * @param academicCalendarForm * @param result * @param request * @param response * @return */ @RequestMapping(params = "methodToCall=deleteAcalEvent") public ModelAndView deleteAcalEvent(@ModelAttribute("KualiForm") AcademicCalendarForm academicCalendarForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { academicCalendarForm.setFieldsToSave(processDirtyFields(academicCalendarForm)); String selectedCollectionPath = academicCalendarForm .getActionParamaterValue(UifParameters.SELECTED_COLLECTION_PATH); if (StringUtils.isBlank(selectedCollectionPath)) { throw new RuntimeException("unable to determine the selected collection path"); } int selectedLineIndex = KSControllerHelper.getSelectedCollectionLineIndex(academicCalendarForm); AcalEventWrapper deletedEvent = academicCalendarForm.getEvents().get(selectedLineIndex); if (deletedEvent.getAcalEventInfo().getId() != null) { academicCalendarForm.getEventsToDeleteOnSave().add(deletedEvent); } academicCalendarForm.getEvents().remove(selectedLineIndex); academicCalendarForm.getAddedCollectionItems().remove(deletedEvent); return getUIFModelAndView(academicCalendarForm); } /** * Method used to set Acal as official */ @RequestMapping(params = "methodToCall=makeAcalOfficial") public ModelAndView makeAcalOfficial(@ModelAttribute("KualiForm") AcademicCalendarForm acalForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { // Dialog confirmation to make the calendar official String dialog = CalendarConstants.ACADEMIC_CALENDAR_OFFICIAL_CONFIRMATION_DIALOG; if (!hasDialogBeenDisplayed(dialog, acalForm)) { acalForm.setMakeOfficialName(acalForm.getAcademicCalendarInfo().getName()); //redirect back to client to display lightbox return showDialog(dialog, acalForm, request, response); } else { if (hasDialogBeenAnswered(dialog, acalForm)) { boolean confirm = getBooleanDialogResponse(dialog, acalForm, request, response); acalForm.getDialogManager().resetDialogStatus(dialog); if (!confirm) { return getUIFModelAndView(acalForm); } } else { //redirect back to client to display lightbox return showDialog(dialog, acalForm, request, response); } } makeAcalOfficial(acalForm); return getUIFModelAndView(acalForm); } public AcademicCalendarService getAcalService() { if (acalService == null) { acalService = (AcademicCalendarService) GlobalResourceLoader .getService(new QName(AcademicCalendarServiceConstants.NAMESPACE, AcademicCalendarServiceConstants.SERVICE_NAME_LOCAL_PART)); } return this.acalService; } public AcademicCalendarServiceFacade getAcademicCalendarServiceFacade() { if (academicCalendarServiceFacade == null) { academicCalendarServiceFacade = (AcademicCalendarServiceFacade) GlobalResourceLoader .getService(new QName(AcademicCalendarServiceConstants.FACADE_NAMESPACE, AcademicCalendarServiceConstants.FACADE_SERVICE_NAME_LOCAL_PART)); } return this.academicCalendarServiceFacade; } protected AcademicCalendarViewHelperService getAcalViewHelperService(AcademicCalendarForm acalForm) { AcademicCalendarViewHelperService viewHelperService = (AcademicCalendarViewHelperService) KSControllerHelper .getViewHelperService(acalForm); return viewHelperService; } /** * Redirects from an academic calendar page to the calendar search page * * @param academicCalendarForm - Calendar form backing the page * @param request - Http requests parameters * @param urlParameters - Additional parameters to pass when redirecting * @return The Calendar search page. */ protected ModelAndView redirectToSearch(AcademicCalendarForm academicCalendarForm, HttpServletRequest request, Properties urlParameters) { urlParameters.put("viewId", CalendarConstants.CALENDAR_SEARCH_VIEW); urlParameters.put("methodToCall", KRADConstants.SEARCH_METHOD); String uri = request.getRequestURL().toString().replace("academicCalendar", "calendarSearch"); return performRedirect(academicCalendarForm, uri, urlParameters); } /** * Changes the state of the term from draft to official * * @param term - The Term to make official * @param acalForm - Tee page form * @return true if the term was made official successfully, false otherwise. */ protected boolean makeTermOfficial(AcademicTermWrapper term, AcademicCalendarForm acalForm) { AcademicCalendarViewHelperService viewHelperService = getAcalViewHelperService(acalForm); StatusInfo statusInfo; try { // no need to check if the term is a sub term. makeTermOfficialCascaded method works for both sub term and non-sub term statusInfo = getAcademicCalendarServiceFacade().makeTermOfficialCascaded(term.getTermInfo().getId(), viewHelperService.createContextInfo()); if (!statusInfo.getIsSuccess()) { GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, RiceKeyConstants.ERROR_CUSTOM, statusInfo.getMessage()); return false; } term.setTermInfo( getAcalService().getTerm(term.getTermInfo().getId(), viewHelperService.createContextInfo())); if (term.isSubTerm()) { // update the parent term so the view displays the proper states (draft vs official) for (AcademicTermWrapper termWrapper : acalForm.getTermWrapperList()) { if (termWrapper.getTermInfo().getId().equals(term.getParentTermInfo().getId())) { TermInfo updatedParentTerm = getAcalService().getTerm(term.getParentTermInfo().getId(), viewHelperService.createContextInfo()); // Make sure the parent term is updated in both the term and the termWrapperList. term.setParentTermInfo(updatedParentTerm); termWrapper.setTermInfo(updatedParentTerm); // the screen looks at this variable } } } for (KeyDatesGroupWrapper groupWrapper : term.getKeyDatesGroupWrappers()) { for (KeyDateWrapper keyDateWrapper : groupWrapper.getKeydates()) { //...skip [unsaved] KeyDates that have null Id ...to avoid exception //note: the UI policy for this page: user must select 'Save' to save changes as make official does not save anything) if (keyDateWrapper.getKeyDateInfo() != null && keyDateWrapper.getKeyDateInfo().getId() != null) { keyDateWrapper.setKeyDateInfo(getAcalService().getKeyDate( keyDateWrapper.getKeyDateInfo().getId(), viewHelperService.createContextInfo())); } } } } catch (Exception e) { getLog().error("Make Official Failed for Term", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_TERM_OFFICIAL_FAILED, e.getMessage()); return false; } return true; } /** * Attempts to make the academic calendar official. * * @param acalForm - Tee page form * @return True if calendar state is successfully changed */ protected boolean makeAcalOfficial(AcademicCalendarForm acalForm) { AcademicCalendarViewHelperService viewHelperService = getAcalViewHelperService(acalForm); try { StatusInfo statusInfo = null; statusInfo = getAcalService().changeAcademicCalendarState(acalForm.getAcademicCalendarInfo().getId(), AcademicCalendarServiceConstants.ACADEMIC_CALENDAR_OFFICIAL_STATE_KEY, viewHelperService.createContextInfo()); if (!statusInfo.getIsSuccess()) { GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, RiceKeyConstants.ERROR_CUSTOM, statusInfo.getMessage()); return false; } else { // Refresh form information acalForm.setAcademicCalendarInfo(getAcalService().getAcademicCalendar( acalForm.getAcademicCalendarInfo().getId(), viewHelperService.createContextInfo())); acalForm.setOfficialCalendar(true); for (AcalEventWrapper eventWrapper : acalForm.getEvents()) { eventWrapper.setAcalEventInfo(getAcalService().getAcalEvent( eventWrapper.getAcalEventInfo().getId(), viewHelperService.createContextInfo())); } } } catch (Exception e) { getLog().error("Make Official Failed for Acal", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_OFFICIAL_FAILED, e.getMessage()); return false; } return true; } /** * Saves changes made to an academic calendar. * * @param academicCalendarForm - Form containing the data from the page. * @return The updated calendar after save. */ protected AcademicCalendarForm saveAcademicCalendarDirtyFields(AcademicCalendarForm academicCalendarForm) { AcademicCalendarViewHelperService viewHelperService = getAcalViewHelperService(academicCalendarForm); // Convert Raw UI data and prepare it for save. viewHelperService.populateAcademicCalendarDefaults(academicCalendarForm); // Validate Acal viewHelperService.validateAcademicCalendar(academicCalendarForm); if (GlobalVariables.getMessageMap().getErrorCount() > 0) { // If there are errors in the validation return current calendar without saving // sort the term wrappers so that error/warning messages can be displayed in the correct sections viewHelperService.sortTermWrappers(academicCalendarForm.getTermWrapperList()); return academicCalendarForm; } // Create list of dirty fields by seperating string from page (See enroll.js:saveAcalPreProcess()) List<String> dirtyFields = processDirtyFields(academicCalendarForm); // Save the base Academic calendar info and refresh it in the form AcademicCalendarInfo newAcal = saveAcal(academicCalendarForm.getAcademicCalendarInfo(), academicCalendarForm, viewHelperService); academicCalendarForm.setAcademicCalendarInfo(newAcal); // Save the dirty field information academicCalendarForm = saveDirtyFieldChanges(academicCalendarForm, dirtyFields, viewHelperService); // Check for new Acal Events and save them academicCalendarForm = saveAcalEvents(academicCalendarForm, viewHelperService); // Check for deleted Acal Events and delete them from database deleteAcalEvents(academicCalendarForm, viewHelperService); // Check for new terms and save them academicCalendarForm = saveTerms(academicCalendarForm, viewHelperService); // Check for deleted terms and delete them from database deleteTerms(academicCalendarForm, viewHelperService); // Check keydates in terms for (int i = 0; i < academicCalendarForm.getTermWrapperList().size(); i++) { // Check for new key dates and save them academicCalendarForm = saveKeyDates(academicCalendarForm, i, viewHelperService); // Check for deleted key dates and delete them from database AcademicTermWrapper term = academicCalendarForm.getTermWrapperList().get(i); deleteKeyDates(term, viewHelperService); // update instructionalDays try { term.setInstructionalDays(getAcalService().getInstructionalDaysForTerm(term.getTermInfo().getId(), viewHelperService.createContextInfo())); } catch (Exception ex) { // If the lookup fails message user getLog().error("Unable to load instructional days", ex); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_CALCULATING_INSTRUCTIONAL_DAYS, term.getStartDate().toString(), term.getEndDate().toString()); } //process exam periods academicCalendarForm = processExamPeriods(academicCalendarForm, i, viewHelperService); } // Reset values academicCalendarForm.getEventsToDeleteOnSave().clear(); academicCalendarForm.getFieldsToSave().clear(); academicCalendarForm.setDirtyFields(""); academicCalendarForm.getTermsToDeleteOnSave().clear(); academicCalendarForm.setNewCalendar(false); // Successful save message if (!(GlobalVariables.getMessageMap().getErrorCount() > 0)) { GlobalVariables.getMessageMap().addGrowlMessage("", CalendarConstants.MessageKeys.INFO_ACADEMIC_CALENDAR_SAVED, academicCalendarForm.getAcademicCalendarInfo().getName()); } academicCalendarForm.setMeta(academicCalendarForm.getAcademicCalendarInfo().getMeta()); // Reseting added collection items since they were saved academicCalendarForm.setAddedCollectionItems(new ArrayList<Object>()); //sort term wrappers by start date viewHelperService.sortTermWrappers(academicCalendarForm.getTermWrapperList()); // Return new form return academicCalendarForm; } /** * Cycles through the list of dirty fields, determines what property they correspond to and updates them. * * @param form - View form containing the Calendar information * @param dirtyFields - List of properties that have unsaved information * @param helperService - View Helper service * @return The updated form */ protected AcademicCalendarForm saveDirtyFieldChanges(AcademicCalendarForm form, List<String> dirtyFields, AcademicCalendarViewHelperService helperService) { List<String> updatedFields = new ArrayList<String>(); // Cycle through the dirty field list and save the individual properties. for (String field : dirtyFields) { if (field.isEmpty()) continue; // Remove sub properties from the one to save field = field.substring(0, field.lastIndexOf(".")); // Check if the property has already been saved. boolean alreadyUpdated = false; for (int j = 0; j < updatedFields.size(); j++) { if (field.compareTo(updatedFields.get(j)) == 0) { alreadyUpdated = true; break; } } if (alreadyUpdated) continue; // Add field to list of saved fields updatedFields.add(field); // Search for the save process for the field if (field.contains("newCollectionLines")) { // Catch known dirty field that are not handled by save continue; } else if (field.contains("academicCalendarInfo")) { // Academic calendar info is always saved continue; } else if (field.contains("events")) { // Save an individual event and refresh it in the form int index = processFieldIndex(field); AcalEventWrapper event = form.getEvents().get(index); AcalEventWrapper newEvent = saveAcalEvent(event, form, helperService); form.getEvents().set(index, newEvent); } else if (field.contains("keydates")) { // Save an individual key date change and refresh it in the form int termIndex = processFieldIndex(field.substring(0, field.indexOf("."))); int keyDateGroupIndex = processFieldIndex( field.substring(field.indexOf("."), field.lastIndexOf("."))); int keyDateIndex = processFieldIndex(field.substring(field.lastIndexOf("."))); KeyDateWrapper keyDateWrapper = form.getTermWrapperList().get(termIndex).getKeyDatesGroupWrappers() .get(keyDateGroupIndex).getKeydates().get(keyDateIndex); KeyDateWrapper newKeyDateWrapper = saveKeyDate(keyDateWrapper, form.getTermWrapperList().get(termIndex), helperService); form.getTermWrapperList().get(termIndex).getKeyDatesGroupWrappers().get(keyDateGroupIndex) .getKeydates().set(keyDateIndex, newKeyDateWrapper); } else if (field.contains("examdates")) { //exempt exam period from dirty field update for now continue; } else if (field.contains("termWrapperList")) { // Save and individual even and refresh it in the form int index = processFieldIndex(field); AcademicTermWrapper term = form.getTermWrapperList().get(index); AcademicTermWrapper newTerm = saveTerm(term, form, helperService); form.getTermWrapperList().set(index, newTerm); } else { // Signal that there is an unknown field found. getLog().warn("Unknown field encounter during save: {}", field); } } return form; } /** * Save changes to a calendar or create it if it has not already been saved * * @param acal - Calendar to be saved * @param form - View form containing the Calendar information * @param helperService - View Helper service * @return The updated calendar with information filled in from the save/create */ protected AcademicCalendarInfo saveAcal(AcademicCalendarInfo acal, AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { // Process holiday calendar info and get calendar info base AcademicCalendarInfo acalInfo = processHolidayCalendars(form); // Save term to database try { if (StringUtils.isBlank(acal.getId())) { // Fill in calendar information starting values acalInfo.setStateKey(AcademicCalendarServiceConstants.ACADEMIC_CALENDAR_DRAFT_STATE_KEY); acalInfo.setTypeKey(AcademicCalendarServiceConstants.ACADEMIC_CALENDAR_TYPE_KEY); RichTextInfo rti = new RichTextInfo(); rti.setPlain(acalInfo.getName()); acalInfo.setDescr(rti); // Save the key date to the database and return created information AcademicCalendarInfo newAcal = getAcalService().createAcademicCalendar( AcademicCalendarServiceConstants.ACADEMIC_CALENDAR_TYPE_KEY, acalInfo, helperService.createContextInfo()); return newAcal; } else { // Update the key date in the datebase and return updated information. AcademicCalendarInfo updatedAcal = getAcalService().updateAcademicCalendar(acal.getId(), acal, helperService.createContextInfo()); return updatedAcal; } } catch (VersionMismatchException e) { // If the calendar being worked on is out of date set up reload and message user form.setReload(true); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, RiceKeyConstants.ERROR_CUSTOM, "You are saving an older version of this calendar. Please click on the reload button to get the newer version."); return acal; } catch (Exception e) { // If the save fails message user getLog().error("Add/update Academic calendar failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_FAILED); return acal; } } /** * Cycles through the list of terms and saves any new terms detected. * * @param form - View form containing the Calendar information * @param helperService - View Helper service * @return The updated form. */ protected AcademicCalendarForm saveTerms(AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { // Check for new terms and save them List<AcademicTermWrapper> subTermsToSave = new ArrayList<AcademicTermWrapper>(); for (int i = 0; i < form.getTermWrapperList().size(); i++) { AcademicTermWrapper term = form.getTermWrapperList().get(i); if (term.getTermInfo().getId() == null) { if (term.isSubTerm()) { // Subterms require the parent term to exist so wait and save all other terms are saved subTermsToSave.add(term); } else { // Save the new term and refresh it in the form AcademicTermWrapper newTerm = saveTerm(term, form, helperService); form.getTermWrapperList().set(i, newTerm); } } } // Save subterms from before for (AcademicTermWrapper subterm : subTermsToSave) { int index = form.getTermWrapperList().indexOf(subterm); // Save the new term and refresh it in the form AcademicTermWrapper newTerm = saveTerm(subterm, form, helperService); form.getTermWrapperList().set(index, newTerm); } return form; } /** * Save changes to a term or create it if it has not already been saved * * @param termWrapper - The term to be saved * @param form - View form containing the Calendar information * @param helperService - View Helper service * @return The updated term with information filled in from the save/create */ protected AcademicTermWrapper saveTerm(AcademicTermWrapper termWrapper, AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { // Create term info base TermInfo term = termWrapper.getTermInfo(); // Fill in key date info from the wrapper term.setEndDate(termWrapper.getEndDate()); term.setStartDate(termWrapper.getStartDate()); term.setName(termWrapper.getName()); term.setTypeKey(termWrapper.getTermType()); // Save term to database try { if (termWrapper.isNew() && !termWrapper.isSubTerm()) { // If term is new and not a sub term. // Save the term to the database and update wrapper information. TermInfo newTerm = getAcalService().createTerm(termWrapper.getTermType(), term, helperService.createContextInfo()); termWrapper.setTermInfo(newTerm); // Add term to the calendar getAcalService().addTermToAcademicCalendar(form.getAcademicCalendarInfo().getId(), termWrapper.getTermInfo().getId(), helperService.createContextInfo()); } else if (termWrapper.isNew() && termWrapper.isSubTerm()) { // If term is new and is a sub term. //Find parent term String parentTermTypeKey = termWrapper.getParentTerm(); TermInfo parentTermInfo = getParentTerm(form.getAcademicCalendarInfo().getId(), parentTermTypeKey, helperService); // Check if Parent term exists if (parentTermInfo == null) { // If not throw exception throw new Exception("Parent Term does not exist. Therefor unable to save subterm."); } else { // If parent exist fill in parent information in term. termWrapper.setParentTermInfo(parentTermInfo); // Save the term to the database and update wrapper information. TermInfo newTerm = getAcalService().createTerm(termWrapper.getTermType(), term, helperService.createContextInfo()); termWrapper.setTermInfo(newTerm); // Add link to parent term getAcalService().addTermToTerm(termWrapper.getParentTermInfo().getId(), termWrapper.getTermInfo().getId(), helperService.createContextInfo()); // Add link to calendar getAcalService().addTermToAcademicCalendar(form.getAcademicCalendarInfo().getId(), termWrapper.getTermInfo().getId(), helperService.createContextInfo()); } } else { //If term already exists // Update the term in the datebase adn update wrapper information. TermInfo updatedTerm = getAcalService().updateTerm(term.getId(), term, helperService.createContextInfo()); termWrapper.setTermInfo(updatedTerm); } } catch (Exception e) { getLog().error("Save term has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_TERM_SAVE_FAILED, termWrapper.getName(), e.getLocalizedMessage()); } return termWrapper; } /** * Determines terms that have been deleted in the UI and deletes them from the database * * @param form - View form containing the Calendar information * @param helperService - View Helper service */ protected void deleteTerms(AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { for (AcademicTermWrapper term : form.getTermsToDeleteOnSave()) { try { getAcademicCalendarServiceFacade().deleteTermCascaded(term.getTermInfo().getId(), helperService.createContextInfo()); } catch (Exception e) { getLog().error("Delete term has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_DELETING, "Term", term.getName()); } } } /** * Cycles through the key date groups and their list of key dates and saves any new keydates detected * * @param form - View form containing the Calendar information * @param termIndex - The index of the term. * @param helperService - View Helper service * @return The updated form. */ protected AcademicCalendarForm saveKeyDates(AcademicCalendarForm form, int termIndex, AcademicCalendarViewHelperService helperService) { AcademicTermWrapper term = form.getTermWrapperList().get(termIndex); for (int j = 0; j < term.getKeyDatesGroupWrappers().size(); j++) { KeyDatesGroupWrapper keyDateGroup = term.getKeyDatesGroupWrappers().get(j); for (int k = 0; k < keyDateGroup.getKeydates().size(); k++) { KeyDateWrapper keyDate = keyDateGroup.getKeydates().get(k); if (keyDate.getKeyDateInfo().getId() == null) { KeyDateWrapper newKeyDate = saveKeyDate(keyDate, term, helperService); form.getTermWrapperList().get(termIndex).getKeyDatesGroupWrappers().get(j).getKeydates().set(k, newKeyDate); } } } return form; } /** * Save changes to a keydate or create it if it has not already been saved * * @param keyDateWrapper - KeyDate to be saved * @param term - Term containing the key date * @param helperService - View helper service * @return The updated keydate with information filled in from the save/create */ protected KeyDateWrapper saveKeyDate(KeyDateWrapper keyDateWrapper, AcademicTermWrapper term, AcademicCalendarViewHelperService helperService) { // Create key date info base KeyDateInfo keyDate = keyDateWrapper.getKeyDateInfo(); // Fill in key date info from the wrapper keyDate.setTypeKey(keyDateWrapper.getKeyDateType()); keyDate.setName(keyDateWrapper.getKeyDateNameUI()); keyDate.setIsAllDay(keyDateWrapper.isAllDay()); keyDate.setIsDateRange(keyDateWrapper.isDateRange()); keyDate.setStartDate(getDateInfoForKeyDate(keyDateWrapper.isAllDay(), keyDateWrapper.getStartDate(), keyDateWrapper.getStartTime(), keyDateWrapper.getStartTimeAmPm())); if (keyDateWrapper.isDateRange()) { keyDate.setEndDate(getDateInfoForKeyDate(keyDateWrapper.isAllDay(), keyDateWrapper.getEndDate(), keyDateWrapper.getEndTime(), keyDateWrapper.getEndTimeAmPm())); } else { keyDate.setEndDate(null); } // Save Key date to database try { if (keyDateWrapper.isNew()) { // Save the key date to the database and update wrapper information. keyDate.setStateKey(AtpServiceConstants.MILESTONE_DRAFT_STATE_KEY); KeyDateInfo createdKeyDate = getAcalService().createKeyDate(term.getTermInfo().getId(), keyDate.getTypeKey(), keyDate, helperService.createContextInfo()); keyDateWrapper.setKeyDateInfo(createdKeyDate); } else { // Update the key date in the datebase adn update wrapper information. KeyDateInfo updatedKeyDate = getAcalService().updateKeyDate(keyDate.getId(), keyDate, helperService.createContextInfo()); keyDateWrapper.setKeyDateInfo(updatedKeyDate); } } catch (Exception e) { getLog().error("Save keydate has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_TERM_KEYDATE_FAILED, keyDateWrapper.getKeyDateNameUI(), term.getName()); } return keyDateWrapper; } /** * Cycles through the exam periods and process each of them * * @param form - View form containing the Calendar information * @param termIndex - The index of the term. * @param helperService - View Helper service * @return The updated form. */ protected AcademicCalendarForm processExamPeriods(AcademicCalendarForm form, int termIndex, AcademicCalendarViewHelperService helperService) { //process add/update of exam period AcademicTermWrapper term = form.getTermWrapperList().get(termIndex); for (int i = 0; i < term.getExamdates().size(); i++) { ExamPeriodWrapper examPeriodWrapper = term.getExamdates().get(i); ExamPeriodWrapper newExamPeriodWrapper = saveExamPeriod(form, examPeriodWrapper, term, termIndex, helperService); form.getTermWrapperList().get(termIndex).getExamdates().set(i, newExamPeriodWrapper); } //process the deletion of exam period for (ExamPeriodWrapper examPeriodToDelete : term.getExamPeriodsToDeleteOnSave()) { try { getAcalService().deleteExamPeriod(examPeriodToDelete.getExamPeriodInfo().getId(), helperService.createContextInfo()); } catch (Exception e) { getLog().error("Delete exam period has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_DELETING, term.getName(), examPeriodToDelete.getExamPeriodNameUI()); } } term.getExamPeriodsToDeleteOnSave().clear(); return form; } /** * Save changes to a exam period or create it if it has not already been saved * * @param examPeriodWrapper - ExamPeriod to be saved * @param term - Term containing the key date * @param helperService - View helper service * @return The updated keydate with information filled in from the save/create */ protected ExamPeriodWrapper saveExamPeriod(AcademicCalendarForm form, ExamPeriodWrapper examPeriodWrapper, AcademicTermWrapper term, int termIndex, AcademicCalendarViewHelperService helperService) { // Create exam period info base ExamPeriodInfo examPeriodInfo = examPeriodWrapper.getExamPeriodInfo(); String examPeriodName = examPeriodWrapper.getExamPeriodNameUI() + " " + term.getName(); // Fill in key date info from the wrapper examPeriodInfo.setTypeKey(examPeriodWrapper.getExamPeriodType()); examPeriodInfo.setName(examPeriodName); examPeriodInfo.setEndDate(examPeriodWrapper.getEndDate()); examPeriodInfo.setStartDate(examPeriodWrapper.getStartDate()); examPeriodInfo.setStateKey(term.getTermInfo().getStateKey()); //the state of the exam period is the same as the term state setExamPeriodAttr(examPeriodInfo, AcademicCalendarServiceConstants.EXAM_PERIOD_EXCLUDE_SATURDAY_ATTR, String.valueOf(examPeriodWrapper.isExcludeSaturday())); setExamPeriodAttr(examPeriodInfo, AcademicCalendarServiceConstants.EXAM_PERIOD_EXCLUDE_SUNDAY_ATTR, String.valueOf(examPeriodWrapper.isExcludeSunday())); RichTextInfo rti = new RichTextInfo(); rti.setPlain(examPeriodName); rti.setFormatted(examPeriodName); examPeriodInfo.setDescr(rti); // Save Exam Period to database try { if (examPeriodWrapper.isNew()) { // Save the exam period to the database and update wrapper information. List<String> termTypeKeyList = new ArrayList<String>(); termTypeKeyList.add(term.getTermType()); ExamPeriodInfo createdExamPeriodInfo = getAcademicCalendarServiceFacade().addExamPeriod( examPeriodInfo.getTypeKey(), termTypeKeyList, examPeriodInfo, helperService.createContextInfo()); getAcalService().addExamPeriodToTerm(term.getTermInfo().getId(), createdExamPeriodInfo.getId(), helperService.createContextInfo()); examPeriodWrapper.setExamPeriodInfo(createdExamPeriodInfo); } else { // Update the exam period in the datebase and update wrapper information. ExamPeriodInfo updatedExamPeriodInfo = getAcalService().updateExamPeriod(examPeriodInfo.getId(), examPeriodInfo, helperService.createContextInfo()); examPeriodWrapper.setExamPeriodInfo(updatedExamPeriodInfo); } } catch (OperationFailedException oe) { getLog().error("Save exam period has failed", oe); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_TERM_EXAMPERIOD_FAILED, examPeriodWrapper.getExamPeriodNameUI(), term.getName() + ". FEP is not allowed for the selected term."); } catch (Exception e) { getLog().error("Save exam period has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_TERM_EXAMPERIOD_FAILED, examPeriodWrapper.getExamPeriodNameUI(), term.getName()); } return examPeriodWrapper; } /** * Determines kay dates that have been deleted in the UI and deletes them from the database * * @param term - term wrapper from form * @param helperService - View Helper service */ protected void deleteKeyDates(AcademicTermWrapper term, AcademicCalendarViewHelperService helperService) { for (KeyDateWrapper keyDate : term.getKeyDatesToDeleteOnSave()) { try { getAcalService().deleteKeyDate(keyDate.getKeyDateInfo().getId(), helperService.createContextInfo()); } catch (Exception e) { getLog().error("Delete key date has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_DELETING, term.getName(), keyDate.getKeyDateNameUI()); } } term.getKeyDatesToDeleteOnSave().clear(); } /** * Cycles through the list of events and saves any new events detected * * @param form - View form containing the Calendar information * @param helperService - View Helper service * @return The updated form. */ protected AcademicCalendarForm saveAcalEvents(AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { for (int i = 0; i < form.getEvents().size(); i++) { AcalEventWrapper event = form.getEvents().get(i); if (event.getAcalEventInfo().getId() == null) { AcalEventWrapper newEvent = saveAcalEvent(event, form, helperService); form.getEvents().set(i, newEvent); } } return form; } /** * Save changes to an event or create it if it has not already been saved * * @param event - The event to be created * @param form - View form containing the Calendar information * @param helperService - The view helper service * @return The updated event with the saved information from its creation. */ protected AcalEventWrapper saveAcalEvent(AcalEventWrapper event, AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { // Create event info base AcalEventInfo eventInfo = event.getAcalEventInfo(); // Fill in event info from the wrapper RichTextInfo rti = new RichTextInfo(); rti.setPlain(event.getEventTypeKey()); eventInfo.setDescr(rti); eventInfo.setTypeKey(event.getEventTypeKey()); eventInfo.setIsAllDay(event.isAllDay()); eventInfo.setIsDateRange(event.isDateRange()); eventInfo.setStartDate(getDateInfoForKeyDate(event.isAllDay(), event.getStartDate(), event.getStartTime(), event.getStartTimeAmPm())); if (event.isDateRange()) { eventInfo.setEndDate(getDateInfoForKeyDate(event.isAllDay(), event.getEndDate(), event.getEndTime(), event.getEndTimeAmPm())); } else { eventInfo.setEndDate(null); } // If calendar is official event is too if (!form.isOfficialCalendar()) { eventInfo.setStateKey(AtpServiceConstants.MILESTONE_DRAFT_STATE_KEY); } else { eventInfo.setStateKey(AtpServiceConstants.MILESTONE_OFFICIAL_STATE_KEY); } // Save Event to database try { if (eventInfo.getId() == null) { // Save the event to the database and update wrapper information. AcalEventInfo createdEventInfo = getAcalService().createAcalEvent( form.getAcademicCalendarInfo().getId(), eventInfo.getTypeKey(), eventInfo, helperService.createContextInfo()); event.setAcalEventInfo(createdEventInfo); } else { // Update the event already in the database and update wrapper information. AcalEventInfo updatedEventInfo = getAcalService().updateAcalEvent(eventInfo.getId(), eventInfo, helperService.createContextInfo()); event.setAcalEventInfo(updatedEventInfo); } } catch (Exception e) { getLog().error("Save calendar event has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_ACAL_SAVE_EVENT_FAILED, event.getEventTypeName()); } return event; } /** * Determines events that have been deleted in the UI and deletes them from the database * * @param form - View form containing the Calendar information * @param helperService - View Helper service */ protected void deleteAcalEvents(AcademicCalendarForm form, AcademicCalendarViewHelperService helperService) { for (AcalEventWrapper event : form.getEventsToDeleteOnSave()) { try { getAcalService().deleteAcalEvent(event.getAcalEventInfo().getId(), helperService.createContextInfo()); } catch (Exception e) { getLog().error("Delete calendar event has failed", e); GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_MESSAGES, CalendarConstants.MessageKeys.ERROR_DELETING, "Calendar event", event.getEventTypeName()); } } } /** * Finds and returns an array index of a property from its field name * * @param field - The property field string in the form propertyName[#] * @return The index of the array slot referenced in the property. */ protected int processFieldIndex(String field) { String indexChar = field.substring(field.indexOf("[") + 1, field.lastIndexOf("]")); return Integer.parseInt(indexChar); } /** * Finds and returns the parent term of a subterm * * @param acalId - Id of the calendar containing the subterm * @param parentTermTypeKey - The type key of the parent term * @param helperService - the view helper service * @return The term info for the parent term * @throws Exception - Exception thrown by the call to the academic calendar service */ protected TermInfo getParentTerm(String acalId, String parentTermTypeKey, AcademicCalendarViewHelperService helperService) throws Exception { List<TermInfo> termInfoList = getAcalService().getTermsForAcademicCalendar(acalId, helperService.createContextInfo()); for (TermInfo termInfo : termInfoList) { if (parentTermTypeKey.equals(termInfo.getTypeKey())) { return termInfo; } } return null; } /** * Creates a Date object with just date or date and time based on if the event is all day or not * * @param isAllDay - Whether event is all day or not * @param date - The MM/dd/yyyy date * @param time - A string of the time * @param ampm - A string of whether the time is am or pm * @return A completed date object based on isAllDay */ protected Date getDateInfoForKeyDate(boolean isAllDay, Date date, String time, String ampm) { if (!isAllDay) { return AcalCommonUtils.getDateWithTime(date, time, ampm); } return date; } /** * Compiles the list of Holiday ids saved in the form to a new list and adds it to the academicCalendarInfo. * * @param academicCalendarForm - View form containing the Calendar information * @return An updated academic calendar info with list of hcals */ protected AcademicCalendarInfo processHolidayCalendars(AcademicCalendarForm academicCalendarForm) { AcademicCalendarInfo acalInfo = academicCalendarForm.getAcademicCalendarInfo(); List<HolidayCalendarWrapper> holidayCalendarList = academicCalendarForm.getHolidayCalendarList(); List<String> holidayCalendarIds = new ArrayList<String>(); if (holidayCalendarList != null && !holidayCalendarList.isEmpty()) { for (HolidayCalendarWrapper hcWrapper : holidayCalendarList) { holidayCalendarIds.add(hcWrapper.getHolidayCalendarInfo().getId()); } } // if the list from the form is empty, then all holiday calendars have been removed (or none have been assigned) acalInfo.setHolidayCalendarIds(holidayCalendarIds); academicCalendarForm.setAcademicCalendarInfo(acalInfo); return acalInfo; } /** * Processes the the string of dirty fields on the form and stores * (Mainly to prevent loss during redirects during dialogs) * * @param academicCalendarForm - View form containing the Calendar information * @return List of diry fields passed from the screen. */ protected List<String> processDirtyFields(AcademicCalendarForm academicCalendarForm) { String[] tempFields = new String[0]; if (academicCalendarForm.getDirtyFields() != null) { tempFields = academicCalendarForm.getDirtyFields().split(","); } List<String> dirtyFields = academicCalendarForm.getFieldsToSave(); StringBuilder completeDirtyFields = new StringBuilder(""); for (String field : tempFields) { boolean alreadySeen = false; for (String field2 : dirtyFields) { if (field2.compareTo(field) == 0) { alreadySeen = true; break; } } if (!alreadySeen) { dirtyFields.add(field); } } for (String field : dirtyFields) { completeDirtyFields.append(field); completeDirtyFields.append(","); } academicCalendarForm.setDirtyFields(completeDirtyFields.toString()); return dirtyFields; } /** * Override of the Krad lightbox return function to allow for returning to the controller without a redirect. * Redirect causes a page refresh. */ @Override @RequestMapping(params = "methodToCall=returnFromLightbox") public ModelAndView returnFromLightbox(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result, HttpServletRequest request, HttpServletResponse response) { String newMethodToCall; // Save user responses from dialog DialogManager dm = form.getDialogManager(); String dialogId = dm.getCurrentDialogId(); if (dialogId == null) { newMethodToCall = "start"; } else { dm.setDialogAnswer(dialogId, form.getDialogResponse()); dm.setDialogExplanation(dialogId, form.getDialogExplanation()); newMethodToCall = dm.getDialogReturnMethod(dialogId); dm.setCurrentDialogId(null); } // KSENROLL Code Start form.setMethodToCall(newMethodToCall); // Attempt to return to the controller method directly using reflection (look for the matching methodToCall) for (Method m : this.getClass().getMethods()) { RequestMapping a = m.getAnnotation(RequestMapping.class); if (a != null) { String[] annotationsParams = a.params(); for (String param : annotationsParams) { if (param.contains("methodToCall=" + newMethodToCall)) { try { return (ModelAndView) m.invoke(this, form, result, request, response); } catch (IllegalAccessException iae) { getLog().error("Reflection Invocation failed", iae); throw new RuntimeException("Error using reflection in returnFromLightbox", iae); } catch (InvocationTargetException ite) { getLog().error("Reflection Invocation failed", ite); throw new RuntimeException("Error using reflection in returnFromLightbox", ite); } catch (IllegalArgumentException iae) { getLog().error("Reflection Invocation failed", iae); throw new RuntimeException("Error using reflection in returnFromLightbox", iae); } } } } } // KSENROLL Code End // call intended controller method Properties props = new Properties(); props.put(UifParameters.METHOD_TO_CALL, newMethodToCall); props.put(UifParameters.VIEW_ID, form.getViewId()); props.put(UifParameters.FORM_KEY, form.getFormKey()); props.put(UifParameters.AJAX_REQUEST, "false"); return performRedirect(form, form.getFormPostUrl(), props); } /** * Override to process and save dirty fields when adding values. */ @Override @RequestMapping(method = RequestMethod.POST, params = "methodToCall=addLine") public ModelAndView addLine(@ModelAttribute("KualiForm") UifFormBase uifForm, BindingResult result, HttpServletRequest request, HttpServletResponse response) { ((AcademicCalendarForm) uifForm).setFieldsToSave(processDirtyFields((AcademicCalendarForm) uifForm)); return super.addLine(uifForm, result, request, response); } protected void setExamPeriodAttr(ExamPeriodInfo examPeriodInfo, String attrKey, String attrValue) { AttributeInfo attributeInfo = getExamPeriodAttrForKey(examPeriodInfo, attrKey); if (attributeInfo != null) { attributeInfo.setValue(attrValue); } else { attributeInfo = AcalCommonUtils.createAttribute(attrKey, attrValue); examPeriodInfo.getAttributes().add(attributeInfo); } } protected AttributeInfo getExamPeriodAttrForKey(ExamPeriodInfo examPeriodInfo, String key) { for (AttributeInfo info : examPeriodInfo.getAttributes()) { if (info.getKey().equals(key)) { return info; } } return null; } protected void setAcalService(AcademicCalendarService acalService) { this.acalService = acalService; } protected void setAcademicCalendarServiceFacade(AcademicCalendarServiceFacade academicCalendarServiceFacade) { this.academicCalendarServiceFacade = academicCalendarServiceFacade; } }