/*

  * Copyright 2005-2007 The Kuali Foundation

  *

  * Licensed under the Educational Community License, Version 2.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/ecl2.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.rice.kns.web.struts.action;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 import javax.persistence.EntityManagerFactory;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.lang.ArrayUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.ojb.broker.OptimisticLockException;

 import org.apache.struts.action.ActionForm;

 import org.apache.struts.action.ActionForward;

 import org.apache.struts.action.ActionMapping;

 import org.apache.struts.upload.FormFile;

 import org.kuali.rice.core.util.KeyLabelPair;

 import org.kuali.rice.core.util.RiceConstants;

 import org.kuali.rice.kew.exception.WorkflowException;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.kim.bo.Group;

 import org.kuali.rice.kim.bo.Person;

 import org.kuali.rice.kim.service.IdentityManagementService;

 import org.kuali.rice.kim.service.KIMServiceLocator;

 import org.kuali.rice.kim.util.KimConstants;

 import org.kuali.rice.kns.UserSession;

 import org.kuali.rice.kns.bo.AdHocRoutePerson;

 import org.kuali.rice.kns.bo.AdHocRouteRecipient;

 import org.kuali.rice.kns.bo.AdHocRouteWorkgroup;

 import org.kuali.rice.kns.bo.Attachment;

 import org.kuali.rice.kns.bo.DocumentHeader;

 import org.kuali.rice.kns.bo.Note;

 import org.kuali.rice.kns.bo.PersistableBusinessObject;

 import org.kuali.rice.kns.datadictionary.DataDictionary;

 import org.kuali.rice.kns.datadictionary.DocumentEntry;

 import org.kuali.rice.kns.document.Document;

 import org.kuali.rice.kns.document.MaintenanceDocument;

 import org.kuali.rice.kns.document.authorization.DocumentAuthorizer;

 import org.kuali.rice.kns.document.authorization.DocumentAuthorizerBase;

 import org.kuali.rice.kns.document.authorization.DocumentPresentationController;

 import org.kuali.rice.kns.document.authorization.PessimisticLock;

 import org.kuali.rice.kns.exception.AuthorizationException;

 import org.kuali.rice.kns.exception.DocumentAuthorizationException;

 import org.kuali.rice.kns.exception.UnknownDocumentIdException;

 import org.kuali.rice.kns.exception.ValidationException;

 import org.kuali.rice.kns.question.ConfirmationQuestion;

 import org.kuali.rice.kns.rule.PromptBeforeValidation;

 import org.kuali.rice.kns.rule.event.AddAdHocRoutePersonEvent;

 import org.kuali.rice.kns.rule.event.AddAdHocRouteWorkgroupEvent;

 import org.kuali.rice.kns.rule.event.AddNoteEvent;

 import org.kuali.rice.kns.rule.event.PromptBeforeValidationEvent;

 import org.kuali.rice.kns.rule.event.SaveDocumentEvent;

 import org.kuali.rice.kns.rule.event.SendAdHocRequestsEvent;

 import org.kuali.rice.kns.service.AttachmentService;

 import org.kuali.rice.kns.service.BusinessObjectAuthorizationService;

 import org.kuali.rice.kns.service.BusinessObjectMetaDataService;

 import org.kuali.rice.kns.service.BusinessObjectService;

 import org.kuali.rice.kns.service.DataDictionaryService;

 import org.kuali.rice.kns.service.DocumentHelperService;

 import org.kuali.rice.kns.service.DocumentService;

 import org.kuali.rice.kns.service.KNSServiceLocator;

 import org.kuali.rice.kns.service.KualiConfigurationService;

 import org.kuali.rice.kns.service.KualiRuleService;

 import org.kuali.rice.kns.service.NoteService;

 import org.kuali.rice.kns.service.ParameterConstants;

 import org.kuali.rice.kns.service.ParameterService;

 import org.kuali.rice.kns.service.PessimisticLockService;

 import org.kuali.rice.kns.util.GlobalVariables;

 import org.kuali.rice.kns.util.KNSConstants;

 import org.kuali.rice.kns.util.KNSPropertyConstants;

 import org.kuali.rice.kns.util.ObjectUtils;

 import org.kuali.rice.kns.util.RiceKeyConstants;

 import org.kuali.rice.kns.util.SessionTicket;

 import org.kuali.rice.kns.util.UrlFactory;

 import org.kuali.rice.kns.util.WebUtils;

 import org.kuali.rice.kns.web.struts.form.BlankFormFile;

 import org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase;

 import org.kuali.rice.kns.web.struts.form.KualiForm;

 import org.kuali.rice.kns.web.struts.form.KualiMaintenanceForm;

 import org.kuali.rice.kns.workflow.service.KualiWorkflowDocument;

 import org.springmodules.orm.ojb.OjbOperationException;

 /**

  * This class handles all of the document handling related actions in terms of passing them from here at a central point to the

  * distributed transactions that actually implement document handling.

  */

 public class KualiDocumentActionBase extends KualiAction {

         private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(KualiDocumentActionBase.class);

     // COMMAND constants which cause docHandler to load an existing document instead of creating a new one

     protected static final String[] DOCUMENT_LOAD_COMMANDS = { 

                     KEWConstants.ACTIONLIST_COMMAND, 

                     KEWConstants.DOCSEARCH_COMMAND, 

                     KEWConstants.SUPERUSER_COMMAND, 

                     KEWConstants.HELPDESK_ACTIONLIST_COMMAND };

     private DataDictionaryService dataDictionaryService;

     private DocumentHelperService documentHelperService;

     private DocumentService documentService;

     private KualiConfigurationService kualiConfigurationService;

     private ParameterService parameterService;

     private PessimisticLockService pessimisticLockService;

     private KualiRuleService kualiRuleService;

     private IdentityManagementService identityManagementService;

     private AttachmentService attachmentService;

     private NoteService noteService;

     private BusinessObjectAuthorizationService businessObjectAuthorizationService;

     private BusinessObjectService businessObjectService;

     private BusinessObjectMetaDataService businessObjectMetaDataService;

     private EntityManagerFactory entityManagerFactory;

         protected void checkAuthorization( ActionForm form, String methodToCall ) throws AuthorizationException {

         if ( !(form instanceof KualiDocumentFormBase) ) {

             super.checkAuthorization(form, methodToCall);

         }

     }

     /**

      * Entry point to all actions.

      *

      * NOTE: No need to hook into execute for handling framwork setup anymore. Just implement the methodToCall for the framework

      * setup, Constants.METHOD_REQUEST_PARAMETER will contain the full parameter, which can be sub stringed for getting framework

      * parameters.

      *

      * @see org.apache.struts.action.Action#execute(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm,

      *      javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)

      */

     @Override

     public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         ActionForward returnForward = mapping.findForward(RiceConstants.MAPPING_BASIC);

         // if found methodToCall, pass control to that method

         try {

             returnForward = super.execute(mapping, form, request, response);

         }

         catch (OjbOperationException e) {

             // special handling for OptimisticLockExceptions

             OjbOperationException ooe = (OjbOperationException) e;

             Throwable cause = ooe.getCause();

             if (cause instanceof OptimisticLockException) {

                 OptimisticLockException ole = (OptimisticLockException) cause;

                 GlobalVariables.getMessageMap().putError(KNSConstants.DOCUMENT_ERRORS, RiceKeyConstants.ERROR_OPTIMISTIC_LOCK);

                 logOjbOptimisticLockException(ole);

             }

             else {

                 // if exceptions are from 'save'

                 throw e;

             }

         }

         finally {

                 if (form instanceof KualiDocumentFormBase) {

                 ((KualiDocumentFormBase) form).setMessageMapFromPreviousRequest(GlobalVariables.getMessageMap());

                 }

         }

         if (form instanceof KualiDocumentFormBase

                         && ((KualiDocumentFormBase)form).isHasWorkflowDocument() ) {

             KualiDocumentFormBase formBase = (KualiDocumentFormBase) form;

             Document document = formBase.getDocument();

             //KULRICE-2210 fix location of document header population

             KualiWorkflowDocument workflowDocument = formBase.getDocument().getDocumentHeader().getWorkflowDocument();

             formBase.populateHeaderFields(workflowDocument);

             formBase.setDocId(document.getDocumentNumber());

             //End of KULRICE-2210 fix

             // check to see if document is a pessimistic lock document

             if (isFormRepresentingLockObject(formBase)) {

                 // form represents a document using the BO class PessimisticLock so we need to skip the authorizations in the next logic check

                     if ( LOG.isDebugEnabled() ) {

                             LOG.debug("Form " + formBase + " represents a PessimisticLock BO object");

                     }

             } else {

             // populates authorization-related fields in KualiDocumentFormBase instances, which are derived from

             // information which is contained in the form but which may be unavailable until this point

             //DocumentAuthorizer documentAuthorizer = KNSServiceLocator.getDocumentAuthorizationService().getDocumentAuthorizer(document);

             //formBase.populateAuthorizationFields(documentAuthorizer);

              populateAuthorizationFields(formBase);

              populateAdHocActionRequestCodes(formBase);

             //set the formBase into userSession if the document is a session document 

             UserSession userSession = (UserSession) request.getSession().getAttribute(KNSConstants.USER_SESSION_KEY); 

             if (WebUtils.isDocumentSession(document, formBase)) { 

                     String formKey = formBase.getFormKey(); 

                     if (StringUtils.isBlank(formBase.getFormKey()) || userSession.retrieveObject(formBase.getFormKey()) == null) { 

                             // generate doc form key here if it does not exist 

                             formKey = GlobalVariables.getUserSession().addObject(form); 

                             formBase.setFormKey(formKey); 

                 }

             }

             // below used by KualiHttpSessionListener to handle lock expiration

                 request.getSession().setAttribute(KNSConstants.DOCUMENT_HTTP_SESSION_KEY, document.getDocumentNumber());

             // set returnToActionList flag, if needed

             if ("displayActionListView".equals(formBase.getCommand())) {

                 formBase.setReturnToActionList(true);

             }

             String attachmentEnabled=

                 getKualiConfigurationService().getPropertyString(

                     KNSConstants.NOTE_ATTACHMENT_ENABLED);

             // Override the document entry

             if (attachmentEnabled != null) {

                 // This is a hack for KULRICE-1602 since the document entry is modified by a

                 // global configuration that overrides the document templates without some sort

                 // of rules or control

                 //DataDictionary dataDictionary = getDataDictionaryService().getDataDictionary();

                 DataDictionary dataDictionary = getDataDictionaryService().getDataDictionary();

                 DocumentEntry entry = dataDictionary.getDocumentEntry(document.getClass().getName());

                 entry.setAllowsNoteAttachments(Boolean.parseBoolean(attachmentEnabled));

             }

                         //the request attribute will be used in KualiRequestProcess#processActionPerform

             if(exitingDocument()){

                     request.setAttribute(KNSConstants.EXITING_DOCUMENT, Boolean.TRUE);

             }

             // pessimistic locking

                 String methodCalledViaDispatch = (String) GlobalVariables.getUserSession().retrieveObject(DocumentAuthorizerBase.USER_SESSION_METHOD_TO_CALL_OBJECT_KEY);

                 if ( (StringUtils.isNotBlank(methodCalledViaDispatch)) && (exitingDocument()) ) {

                     GlobalVariables.getUserSession().removeObject(DocumentAuthorizerBase.USER_SESSION_METHOD_TO_CALL_COMPLETE_OBJECT_KEY);

                     attemptLockRelease(document, methodCalledViaDispatch);

                 }

                 setupPessimisticLockMessages(document, request);

                 if (!document.getPessimisticLocks().isEmpty()) {

                     String warningMinutes = getParameterService().getParameterValue(KNSConstants.KNS_NAMESPACE, KNSConstants.DetailTypes.DOCUMENT_DETAIL_TYPE, KNSConstants.SESSION_TIMEOUT_WARNING_MESSAGE_TIME_PARM_NM);

                     request.setAttribute(KNSConstants.SESSION_TIMEOUT_WARNING_MINUTES, warningMinutes);

                     request.setAttribute(KNSConstants.SESSION_TIMEOUT_WARNING_MILLISECONDS, (request.getSession().getMaxInactiveInterval() - (Integer.valueOf(warningMinutes) * 60)) * 1000);

                 }

             }

         }

         return returnForward;

     }

     protected boolean isFormRepresentingLockObject(KualiDocumentFormBase form) throws Exception {

         if (form instanceof KualiMaintenanceForm) {

             KualiMaintenanceForm maintForm = (KualiMaintenanceForm) form;

             if (ObjectUtils.isNotNull(maintForm.getBusinessObjectClassName())) {

                 return PessimisticLock.class.isAssignableFrom(Class.forName(((KualiMaintenanceForm) form).getBusinessObjectClassName()));

             }

         }

         return false;

     }

     protected void attemptLockRelease(Document document, String methodToCall) {

         if ( (document != null) && (!document.getPessimisticLocks().isEmpty()) ) {

             releaseLocks(document, methodToCall);

             // refresh pessimistic locks in case custom add/remove changes were made

             document.refreshPessimisticLocks();

         }

     }

     protected void releaseLocks(Document document, String methodToCall) {

         // first check if the method to call is listed as required lock clearing

         if (document.getLockClearningMethodNames().contains(methodToCall)) {

             // find all locks for the current user and remove them

             getPessimisticLockService().releaseAllLocksForUser(document.getPessimisticLocks(), GlobalVariables.getUserSession().getPerson());

         }

     }

     protected void setupPessimisticLockMessages(Document document, HttpServletRequest request) {

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

         for (PessimisticLock lock : document.getPessimisticLocks()) {

             // if lock is owned by current user, do not display message for it

             if (!lock.isOwnedByUser(GlobalVariables.getUserSession().getPerson())) {

                 lockMessages.add(generatePessimisticLockMessage(lock));

             }

         }

         request.setAttribute(KNSConstants.PESSIMISTIC_LOCK_MESSAGES, lockMessages);

     }

     protected String generatePessimisticLockMessage(PessimisticLock lock) {

         String descriptor = (lock.getLockDescriptor() != null) ? lock.getLockDescriptor() : "";

         // TODO: this should be pulled into a properties file

         return "This document currently has a " + descriptor + " lock owned by " + lock.getOwnedByUser().getName() + " as of " + RiceConstants.getDefaultTimeFormat().format(lock.getGeneratedTimestamp()) + " on " + RiceConstants.getDefaultDateFormat().format(lock.getGeneratedTimestamp());

     }

 //    private void saveMessages(HttpServletRequest request) {

 //        if (!GlobalVariables.getMessageList().isEmpty()) {

 //            request.setAttribute(KNSConstants.GLOBAL_MESSAGES, GlobalVariables.getMessageList());

 //        }

 //    }

     /**

      * This method may be used to funnel all document handling through, we could do useful things like log and record various

      * openings and status Additionally it may be nice to have a single dispatcher that can know how to dispatch to a redirect url

      * for document specific handling but we may not need that as all we should need is the document to be able to load itself based

      * on document id and then which actionforward or redirect is pertinent for the document type.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward docHandler(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         String command = kualiDocumentFormBase.getCommand();

         // in all of the following cases we want to load the document

         if (ArrayUtils.contains(DOCUMENT_LOAD_COMMANDS, command) && kualiDocumentFormBase.getDocId() != null) {

             loadDocument(kualiDocumentFormBase);

         }

         else if (KEWConstants.INITIATE_COMMAND.equals(command)) {

             createDocument(kualiDocumentFormBase);

         }

         else {

             LOG.error("docHandler called with invalid parameters");

             throw new IllegalStateException("docHandler called with invalid parameters");

         }

         // attach any extra JS from the data dictionary

         if (LOG.isDebugEnabled()) {

             LOG.debug("kualiDocumentFormBase.getAdditionalScriptFiles(): " + kualiDocumentFormBase.getAdditionalScriptFiles());

         }

         if ( kualiDocumentFormBase.getAdditionalScriptFiles().isEmpty() ) {

             DocumentEntry docEntry = getDataDictionaryService().getDataDictionary().getDocumentEntry( kualiDocumentFormBase.getDocument().getDocumentHeader().getWorkflowDocument().getDocumentType() );

             kualiDocumentFormBase.getAdditionalScriptFiles().addAll(docEntry.getWebScriptFiles());

         }

         if (KEWConstants.SUPERUSER_COMMAND.equalsIgnoreCase(command)) {

             kualiDocumentFormBase.setSuppressAllButtons(true);

         }

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * This method loads the document by its provided document header id. This has been abstracted out so that it can be overridden

      * in children if the need arises.

      *

      * @param kualiDocumentFormBase

      * @throws WorkflowException

      */

     protected void loadDocument(KualiDocumentFormBase kualiDocumentFormBase) throws WorkflowException {

         String docId = kualiDocumentFormBase.getDocId();

         Document doc = null;

         doc = getDocumentService().getByDocumentHeaderId(docId);

         if (doc == null) {

             throw new UnknownDocumentIdException("Document no longer exists.  It may have been cancelled before being saved.");

         }

         KualiWorkflowDocument workflowDocument = doc.getDocumentHeader().getWorkflowDocument();

         if (!getDocumentHelperService().getDocumentAuthorizer(doc).canOpen(doc, GlobalVariables.getUserSession().getPerson())) {

                 throw buildAuthorizationException("open", doc);

         }

         // re-retrieve the document using the current user's session - remove the system user from the WorkflowDcument object

         if ( workflowDocument != doc.getDocumentHeader().getWorkflowDocument() ) {

                 LOG.warn( "Workflow document changed via canOpen check" );

                 doc.getDocumentHeader().setWorkflowDocument(workflowDocument);

         }

         kualiDocumentFormBase.setDocument(doc);

         KualiWorkflowDocument workflowDoc = doc.getDocumentHeader().getWorkflowDocument();

         kualiDocumentFormBase.setDocTypeName(workflowDoc.getDocumentType());

         // KualiDocumentFormBase.populate() needs this updated in the session

         GlobalVariables.getUserSession().setWorkflowDocument(workflowDoc);

     }

     /**

      * This method creates a new document of the type specified by the docTypeName property of the given form. This has been

      * abstracted out so that it can be overridden in children if the need arises.

      *

      * @param kualiDocumentFormBase

      * @throws WorkflowException

      */

     protected void createDocument(KualiDocumentFormBase kualiDocumentFormBase) throws WorkflowException {

         Document doc = getDocumentService().getNewDocument(kualiDocumentFormBase.getDocTypeName());

         kualiDocumentFormBase.setDocument(doc);

         kualiDocumentFormBase.setDocTypeName(doc.getDocumentHeader().getWorkflowDocument().getDocumentType());

     }

     /**

      * This method will insert the new ad hoc person from the from into the list of ad hoc person recipients, put a new new record

      * in place and return like normal.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward insertAdHocRoutePerson(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         Document document = kualiDocumentFormBase.getDocument();

         // check authorization for adding ad hoc route person

         DocumentAuthorizer documentAuthorizer = getDocumentHelperService().getDocumentAuthorizer(document);

         if(!documentAuthorizer.canSendAdHocRequests(document, kualiDocumentFormBase.getNewAdHocRoutePerson().getActionRequested(), GlobalVariables.getUserSession().getPerson())){

                  throw buildAuthorizationException("ad-hoc route", document);

         }

         // check business rules

         boolean rulePassed = getKualiRuleService().applyRules(new AddAdHocRoutePersonEvent(document, (AdHocRoutePerson) kualiDocumentFormBase.getNewAdHocRoutePerson()));

         // if the rule evaluation passed, let's add the ad hoc route person

         if (rulePassed) {

             // uppercase userid for consistency

 //            kualiDocumentFormBase.getNewAdHocRoutePerson().setId(StringUtils.upperCase(kualiDocumentFormBase.getNewAdHocRoutePerson().getId()));

                 kualiDocumentFormBase.getNewAdHocRoutePerson().setId(kualiDocumentFormBase.getNewAdHocRoutePerson().getId());

             kualiDocumentFormBase.getAdHocRoutePersons().add(kualiDocumentFormBase.getNewAdHocRoutePerson());

             AdHocRoutePerson person = new AdHocRoutePerson();

             kualiDocumentFormBase.setNewAdHocRoutePerson(person);

         }

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * This method will delete one of the ad hoc persons from the list of ad hoc persons to route to based on the line number of the

      * delete button that was clicked. then it will return to the form.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward deleteAdHocRoutePerson(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         kualiDocumentFormBase.getAdHocRoutePersons().remove(this.getLineToDelete(request));

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * This method will insert the new ad hoc workgroup into the list of ad hoc workgroup recipients put a nuew record in place and

      * then return like normal.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward insertAdHocRouteWorkgroup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         Document document = kualiDocumentFormBase.getDocument();

         // check authorization for add ad hoc route workgroup

         DocumentAuthorizer documentAuthorizer = getDocumentHelperService().getDocumentAuthorizer(document);

         if(!documentAuthorizer.canSendAdHocRequests(document, kualiDocumentFormBase.getNewAdHocRouteWorkgroup().getActionRequested(), GlobalVariables.getUserSession().getPerson())){

                  throw buildAuthorizationException("ad-hoc route", document);

         }

         // check business rules

         boolean rulePassed = getKualiRuleService().applyRules(new AddAdHocRouteWorkgroupEvent(document, (AdHocRouteWorkgroup) kualiDocumentFormBase.getNewAdHocRouteWorkgroup()));

         // if the rule evaluation passed, let's add the ad hoc route workgroup

         if (rulePassed) {

             //fill id if not already filled

             AdHocRouteWorkgroup newWorkgroup = kualiDocumentFormBase.getNewAdHocRouteWorkgroup();

             if (newWorkgroup.getId() == null) {

                 newWorkgroup.setId(KIMServiceLocator.getIdentityManagementService().getGroupByName(newWorkgroup.getRecipientNamespaceCode(), newWorkgroup.getRecipientName()).getGroupId());

             }

             kualiDocumentFormBase.getAdHocRouteWorkgroups().add(newWorkgroup);

             AdHocRouteWorkgroup workgroup = new AdHocRouteWorkgroup();

             kualiDocumentFormBase.setNewAdHocRouteWorkgroup(workgroup);

         }

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * This method will delete one of the ad hoc workgroups from the list of ad hoc workgroups to route to based on the line number

      * of the delete button that was clicked. then it will return

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward deleteAdHocRouteWorkgroup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         kualiDocumentFormBase.getAdHocRouteWorkgroups().remove(this.getLineToDelete(request));

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     public ActionForward sendAdHocRequests(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

             KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

             Document document = kualiDocumentFormBase.getDocument();

             boolean rulePassed = getKualiRuleService().applyRules(new SendAdHocRequestsEvent(document));

             if (rulePassed) {

                     getDocumentService().sendAdHocRequests(document, kualiDocumentFormBase.getAnnotation(), combineAdHocRecipients(kualiDocumentFormBase));

                     GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_SEND_AD_HOC_REQUESTS_SUCCESSFUL);

             }

             return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * This method will reload the document.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward reload(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         Document document = kualiDocumentFormBase.getDocument();

         // prepare for the reload action - set doc id and command

         kualiDocumentFormBase.setDocId(document.getDocumentNumber());

         kualiDocumentFormBase.setCommand(DOCUMENT_LOAD_COMMANDS[1]);

         // forward off to the doc handler

         ActionForward actionForward = docHandler(mapping, form, request, response);

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_RELOADED);

         // TODO: remove this when further testing passed

 //        if (form instanceof KualiDocumentFormBase) {

 //            UserSession userSession = (UserSession) request.getSession().getAttribute(RiceConstants.USER_SESSION_KEY);

 //            // force to recreate formkey in execute method

 //            if (document instanceof SessionDocument && userSession.retrieveObject(kualiDocumentFormBase.getFormKey()) != null) {

 //                userSession.removeObject(kualiDocumentFormBase.getFormKey());;

 //            }

 //        }

         return actionForward;

     }

     /**

      * This method will save the document, which will then be available via the action list for the person who saved the document.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward save(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

         //get any possible changes to to adHocWorkgroups

         refreshAdHocRoutingWorkgroupLookups(request, kualiDocumentFormBase);

         Document document = kualiDocumentFormBase.getDocument();

         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response, KNSPropertyConstants.DOCUMENT_EXPLANATION, document.getDocumentHeader().getExplanation(), "save", "");

         if (forward != null) {

                 return forward;

         }

         // save in workflow

         getDocumentService().saveDocument(document);

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_SAVED);

         kualiDocumentFormBase.setAnnotation("");

         // TODO: remove this when further testing passed

 //        if (form instanceof KualiDocumentFormBase) {

 //            UserSession userSession = (UserSession) request.getSession().getAttribute(RiceConstants.USER_SESSION_KEY);

 //            // force to recreate formkey in execute method

 //            if (document instanceof SessionDocument && userSession.retrieveObject(kualiDocumentFormBase.getFormKey()) != null) {

 //                userSession.removeObject(kualiDocumentFormBase.getFormKey());;

 //            }

 //        }

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

         /**

          * Checks if the given value matches patterns that indicate sensitive data and if configured to give a warning for sensitive data will

          * prompt the user to continue

          * 

          * @param mapping

          * @param form

          * @param request

          * @param response

          * @param fieldName - name of field with value being checked

          * @param fieldValue

          *            - value to check for sensitive data

          * @param caller - method that should be called back from question

          * @param context - additional context that needs to be passed back with the question response

          * @return ActionForward which contains the question forward, or basic forward if user select no to prompt, otherwise will return null

          *         to indicate processing should continue

          * @throws Exception

          */

         protected ActionForward checkAndWarnAboutSensitiveData(ActionMapping mapping, ActionForm form,

                         HttpServletRequest request, HttpServletResponse response, String fieldName, String fieldValue, String caller, String context)

                         throws Exception {

                 KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

                 Document document = kualiDocumentFormBase.getDocument();

                 boolean containsSensitiveData = WebUtils.containsSensitiveDataPatternMatch(fieldValue);

                 // check if warning is configured in which case we will prompt, or if not business rules will thrown an error

                 boolean warnForSensitiveData = KNSServiceLocator.getParameterService().getIndicatorParameter(

                                 KNSConstants.KNS_NAMESPACE, ParameterConstants.ALL_COMPONENT,

                                 KNSConstants.SystemGroupParameterNames.SENSITIVE_DATA_PATTERNS_WARNING_IND);

                 // determine if the question has been asked yet

                 Map<String, String> ticketContext = new HashMap<String, String>();

                 ticketContext.put(KNSPropertyConstants.DOCUMENT_NUMBER, document.getDocumentNumber());

                 ticketContext.put(KNSConstants.CALLING_METHOD, caller);

                 ticketContext.put(KNSPropertyConstants.NAME, fieldName);

                 boolean questionAsked = GlobalVariables.getUserSession().hasMatchingSessionTicket(

                                 KNSConstants.SENSITIVE_DATA_QUESTION_SESSION_TICKET, ticketContext);

                 // start in logic for confirming the sensitive data

                 if (containsSensitiveData && warnForSensitiveData && !questionAsked) {

                         Object question = request.getParameter(KNSConstants.QUESTION_INST_ATTRIBUTE_NAME);

                         if (question == null || !KNSConstants.DOCUMENT_SENSITIVE_DATA_QUESTION.equals(question)) {

                                 // question hasn't been asked, prompt to continue

                                 return this.performQuestionWithoutInput(mapping, form, request, response,

                                                 KNSConstants.DOCUMENT_SENSITIVE_DATA_QUESTION, getKualiConfigurationService()

                                                                 .getPropertyString(RiceKeyConstants.QUESTION_SENSITIVE_DATA_DOCUMENT),

                                                 KNSConstants.CONFIRMATION_QUESTION, caller, context);

                         }

                         Object buttonClicked = request.getParameter(KNSConstants.QUESTION_CLICKED_BUTTON);

                         if (question != null && KNSConstants.DOCUMENT_SENSITIVE_DATA_QUESTION.equals(question)) {

                                 // if no button clicked just reload the doc

                                 if (ConfirmationQuestion.NO.equals(buttonClicked)) {

                                         return mapping.findForward(RiceConstants.MAPPING_BASIC);

                                 }

                                 // answered yes, create session ticket so we not to ask question again if there are further question requests

                                 SessionTicket ticket = new SessionTicket(KNSConstants.SENSITIVE_DATA_QUESTION_SESSION_TICKET);

                                 ticket.setTicketContext(ticketContext);

                                 GlobalVariables.getUserSession().putSessionTicket(ticket);

                         }

                 }

                 // return null to indicate processing should continue (no redirect)

                 return null;

         }

     /**

      * This method will verify that the form is representing a {@link PessimisticLock} object and delete it if possible

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward delete(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         if (isFormRepresentingLockObject(kualiDocumentFormBase)) {

             String idValue = request.getParameter(KNSPropertyConstants.ID);

             getPessimisticLockService().delete(idValue);

             return returnToSender(request, mapping, kualiDocumentFormBase);

         }

         throw buildAuthorizationException(KNSConstants.DELETE_METHOD, kualiDocumentFormBase.getDocument());

     }

     /**

      * route the document using the document service

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward performRouteReport(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         kualiDocumentFormBase.setDerivedValuesOnForm(request);

         ActionForward preRulesForward = promptBeforeValidation(mapping, form, request, response);

         if (preRulesForward != null) {

             return preRulesForward;

         }

         Document document = kualiDocumentFormBase.getDocument();

         // check authorization for reloading document

         //DocumentActionFlags flags = getDocumentActionFlags(document);

         if (!kualiDocumentFormBase.getDocumentActions().containsKey(KNSConstants.KUALI_ACTION_PERFORM_ROUTE_REPORT)) {

             throw buildAuthorizationException("perform route report", document);

         }

         String backUrlBase = getReturnLocation(request, mapping);

         String globalVariableFormKey = GlobalVariables.getUserSession().addObject(form);

         // setup back form variables

         request.setAttribute("backUrlBase", backUrlBase);

         List<KeyLabelPair> backFormParameters = new ArrayList<KeyLabelPair>();

         backFormParameters.add(new KeyLabelPair(KNSConstants.DISPATCH_REQUEST_PARAMETER,KNSConstants.RETURN_METHOD_TO_CALL));

         backFormParameters.add(new KeyLabelPair(KNSConstants.DOC_FORM_KEY,globalVariableFormKey));

         request.setAttribute("backFormHiddenVariables", backFormParameters);

         // setup route report form variables

         request.setAttribute("workflowRouteReportUrl", getKualiConfigurationService().getPropertyString(KNSConstants.WORKFLOW_URL_KEY) + "/" + KEWConstants.DOCUMENT_ROUTING_REPORT_PAGE);

         List<KeyLabelPair> generalRouteReportFormParameters = new ArrayList<KeyLabelPair>();

         generalRouteReportFormParameters.add(new KeyLabelPair(KEWConstants.INITIATOR_ID_ATTRIBUTE_NAME, document.getDocumentHeader().getWorkflowDocument().getRouteHeader().getInitiatorPrincipalId()));

         generalRouteReportFormParameters.add(new KeyLabelPair(KEWConstants.DOCUMENT_TYPE_NAME_ATTRIBUTE_NAME,document.getDocumentHeader().getWorkflowDocument().getDocumentType()));

         // prepareForRouteReport() method should populate document header workflow document application content xml

         String xml = document.getXmlForRouteReport();

         if ( LOG.isDebugEnabled() ) {

                 LOG.debug("XML being used for Routing Report is: " + xml);

         }

         generalRouteReportFormParameters.add(new KeyLabelPair(KEWConstants.DOCUMENT_CONTENT_ATTRIBUTE_NAME,xml));

         // set up the variables for the form if java script is working (includes a close button variable and no back url)

         List<KeyLabelPair> javaScriptFormParameters = new ArrayList<KeyLabelPair>();

         javaScriptFormParameters.addAll(generalRouteReportFormParameters);

         javaScriptFormParameters.add(new KeyLabelPair(KEWConstants.DISPLAY_CLOSE_BUTTON_ATTRIBUTE_NAME, KEWConstants.DISPLAY_CLOSE_BUTTON_TRUE_VALUE));

         request.setAttribute("javaScriptFormVariables", javaScriptFormParameters);

         // set up the variables for the form if java script is NOT working (includes a back url but no close button)

         List<KeyLabelPair> noJavaScriptFormParameters = new ArrayList<KeyLabelPair>();

         noJavaScriptFormParameters.addAll(generalRouteReportFormParameters);

         Properties parameters = new Properties();

         for (KeyLabelPair pair : backFormParameters) {

             parameters.put(pair.getKey(), pair.getLabel());

         }

         noJavaScriptFormParameters.add(new KeyLabelPair(KEWConstants.RETURN_URL_ATTRIBUTE_NAME,UrlFactory.parameterizeUrl(backUrlBase, parameters)));

         request.setAttribute("noJavaScriptFormVariables", noJavaScriptFormParameters);

         return mapping.findForward(KNSConstants.MAPPING_ROUTE_REPORT);

     }

     /**

      * route the document using the document service

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward route(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

         kualiDocumentFormBase.setDerivedValuesOnForm(request);

         ActionForward preRulesForward = promptBeforeValidation(mapping, form, request, response);

         if (preRulesForward != null) {

             return preRulesForward;

         }

         Document document = kualiDocumentFormBase.getDocument();

         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response, KNSPropertyConstants.DOCUMENT_EXPLANATION, document.getDocumentHeader().getExplanation(), "route", "");

         if (forward != null) {

                 return forward;

         }

         getDocumentService().routeDocument(document, kualiDocumentFormBase.getAnnotation(), combineAdHocRecipients(kualiDocumentFormBase));

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_SUCCESSFUL);

         kualiDocumentFormBase.setAnnotation("");

 //        GlobalVariables.getUserSession().addObject(DocumentAuthorizerBase.USER_SESSION_METHOD_TO_CALL_COMPLETE_OBJECT_KEY,Boolean.TRUE);

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * Calls the document service to blanket approve the document

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward blanketApprove(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

             KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

             kualiDocumentFormBase.setDerivedValuesOnForm(request);

         ActionForward preRulesForward = promptBeforeValidation(mapping, form, request, response);

         if (preRulesForward != null) {

             return preRulesForward;

         }

         Document document = kualiDocumentFormBase.getDocument();

         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response, KNSPropertyConstants.DOCUMENT_EXPLANATION, document.getDocumentHeader().getExplanation(), "blanketApprove", "");

         if (forward != null) {

                 return forward;

         }

         getDocumentService().blanketApproveDocument(document, kualiDocumentFormBase.getAnnotation(), combineAdHocRecipients(kualiDocumentFormBase));

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_APPROVED);

         kualiDocumentFormBase.setAnnotation("");

         return returnToSender(request, mapping, kualiDocumentFormBase);

     }

     /**

      * Calls the document service to approve the document

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward approve(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

             KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

             kualiDocumentFormBase.setDerivedValuesOnForm(request);

             ActionForward preRulesForward = promptBeforeValidation(mapping, form, request, response);

         if (preRulesForward != null) {

             return preRulesForward;

         }

         Document document = kualiDocumentFormBase.getDocument();

         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response, KNSPropertyConstants.DOCUMENT_EXPLANATION, document.getDocumentHeader().getExplanation(), "approve", "");

         if (forward != null) {

                 return forward;

         }

         getDocumentService().approveDocument(document, kualiDocumentFormBase.getAnnotation(), combineAdHocRecipients(kualiDocumentFormBase));

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_APPROVED);

         kualiDocumentFormBase.setAnnotation("");

         return returnToSender(request, mapping, kualiDocumentFormBase);

     }

     /**

      * Calls the document service to disapprove the document

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

         public ActionForward disapprove(ActionMapping mapping, ActionForm form, HttpServletRequest request,

                         HttpServletResponse response) throws Exception {

                 Object question = request.getParameter(KNSConstants.QUESTION_INST_ATTRIBUTE_NAME);

                 String reason = request.getParameter(KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME);

                 if (StringUtils.isBlank(reason)) {

                         String context = request.getParameter(KNSConstants.QUESTION_CONTEXT);

                         if (context != null && StringUtils.contains(context, KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME + "=")) {

                                 reason = StringUtils.substringAfter(context, KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME + "=");

                         }

                 }

                 String disapprovalNoteText = "";

                 // start in logic for confirming the disapproval

                 if (question == null) {

                         // ask question if not already asked

                         return this.performQuestionWithInput(mapping, form, request, response,

                                         KNSConstants.DOCUMENT_DISAPPROVE_QUESTION,

                                         getKualiConfigurationService().getPropertyString(RiceKeyConstants.QUESTION_DISAPPROVE_DOCUMENT),

                                         KNSConstants.CONFIRMATION_QUESTION, KNSConstants.MAPPING_DISAPPROVE, "");

                 }

                 Object buttonClicked = request.getParameter(KNSConstants.QUESTION_CLICKED_BUTTON);

                 if ((KNSConstants.DOCUMENT_DISAPPROVE_QUESTION.equals(question))

                                 && ConfirmationQuestion.NO.equals(buttonClicked)) {

                         // if no button clicked just reload the doc

                         return mapping.findForward(RiceConstants.MAPPING_BASIC);

                 }

                 // have to check length on value entered

                 String introNoteMessage = getKualiConfigurationService().getPropertyString(

                                 RiceKeyConstants.MESSAGE_DISAPPROVAL_NOTE_TEXT_INTRO)

                                 + KNSConstants.BLANK_SPACE;

                 // build out full message

                 disapprovalNoteText = introNoteMessage + reason;

                 // check for sensitive data in note

                 boolean warnForSensitiveData = KNSServiceLocator.getParameterService().getIndicatorParameter(

                                 KNSConstants.KNS_NAMESPACE, ParameterConstants.ALL_COMPONENT,

                                 KNSConstants.SystemGroupParameterNames.SENSITIVE_DATA_PATTERNS_WARNING_IND);

                 if (warnForSensitiveData) {

                         String context = KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME + "=" + reason;

                         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response,

                                         KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME, disapprovalNoteText, "disapprove", context);

                         if (forward != null) {

                                 return forward;

                         }

                 } else {

                         if (WebUtils.containsSensitiveDataPatternMatch(disapprovalNoteText)) {

                                 return this

                                                 .performQuestionWithInputAgainBecauseOfErrors(mapping, form, request, response,

                                                                 KNSConstants.DOCUMENT_DISAPPROVE_QUESTION, getKualiConfigurationService()

                                                                                 .getPropertyString(RiceKeyConstants.QUESTION_DISAPPROVE_DOCUMENT),

                                                                 KNSConstants.CONFIRMATION_QUESTION, KNSConstants.MAPPING_DISAPPROVE, "", reason,

                                                                 RiceKeyConstants.ERROR_DOCUMENT_FIELD_CONTAINS_POSSIBLE_SENSITIVE_DATA,

                                                                 KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME, "reason");

                         }

                 }

                 int disapprovalNoteTextLength = disapprovalNoteText.length();

                 // get note text max length from DD

                 int noteTextMaxLength = getDataDictionaryService().getAttributeMaxLength(Note.class,

                                 KNSConstants.NOTE_TEXT_PROPERTY_NAME).intValue();

                 if (StringUtils.isBlank(reason) || (disapprovalNoteTextLength > noteTextMaxLength)) {

                         // figure out exact number of characters that the user can enter

                         int reasonLimit = noteTextMaxLength - disapprovalNoteTextLength;

                         if (reason == null) {

                                 // prevent a NPE by setting the reason to a blank string

                                 reason = "";

                         }

                         return this.performQuestionWithInputAgainBecauseOfErrors(mapping, form, request, response,

                                         KNSConstants.DOCUMENT_DISAPPROVE_QUESTION,

                                         getKualiConfigurationService().getPropertyString(RiceKeyConstants.QUESTION_DISAPPROVE_DOCUMENT),

                                         KNSConstants.CONFIRMATION_QUESTION, KNSConstants.MAPPING_DISAPPROVE, "", reason,

                                         RiceKeyConstants.ERROR_DOCUMENT_DISAPPROVE_REASON_REQUIRED,

                                         KNSConstants.QUESTION_REASON_ATTRIBUTE_NAME, new Integer(reasonLimit).toString());

                 }

                 KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

                 doProcessingAfterPost(kualiDocumentFormBase, request);

                 getDocumentService().disapproveDocument(kualiDocumentFormBase.getDocument(), disapprovalNoteText);

                 GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_DISAPPROVED);

                 kualiDocumentFormBase.setAnnotation("");

                 return returnToSender(request, mapping, kualiDocumentFormBase);

         }

     /**

      * Calls the document service to cancel the document

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward cancel(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         Object question = request.getParameter(KNSConstants.QUESTION_INST_ATTRIBUTE_NAME);

         // this should probably be moved into a private instance variable

         // logic for cancel question

         if (question == null) {

             // ask question if not already asked

             return this.performQuestionWithoutInput(mapping, form, request, response, KNSConstants.DOCUMENT_CANCEL_QUESTION, getKualiConfigurationService().getPropertyString("document.question.cancel.text"), KNSConstants.CONFIRMATION_QUESTION, KNSConstants.MAPPING_CANCEL, "");

         }

         else {

             Object buttonClicked = request.getParameter(KNSConstants.QUESTION_CLICKED_BUTTON);

             if ((KNSConstants.DOCUMENT_CANCEL_QUESTION.equals(question)) && ConfirmationQuestion.NO.equals(buttonClicked)) {

                 // if no button clicked just reload the doc

                 return mapping.findForward(RiceConstants.MAPPING_BASIC);

             }

             // else go to cancel logic below

         }

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

         // KULRICE-4447 Call cancelDocument() only if the document exists

         if ( getDocumentService().documentExists(kualiDocumentFormBase.getDocId()))

         {

         getDocumentService().cancelDocument(kualiDocumentFormBase.getDocument(), kualiDocumentFormBase.getAnnotation());

         }

         return returnToSender(request, mapping, kualiDocumentFormBase);

     }

     /**

      * Close the document and take the user back to the index; only after asking the user if they want to save the document first.

      * Only users who have the "canSave()" permission are given this option.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward close(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase docForm = (KualiDocumentFormBase) form;

         doProcessingAfterPost( docForm, request );

         Document document = docForm.getDocument();

         // only want to prompt them to save if they already can save

         if (canSave(docForm)) {

             Object question = getQuestion(request);

             // logic for close question

             if (question == null) {

                 // ask question if not already asked

                 return this.performQuestionWithoutInput(mapping, form, request, response, KNSConstants.DOCUMENT_SAVE_BEFORE_CLOSE_QUESTION, getKualiConfigurationService().getPropertyString(RiceKeyConstants.QUESTION_SAVE_BEFORE_CLOSE), KNSConstants.CONFIRMATION_QUESTION, KNSConstants.MAPPING_CLOSE, "");

             }

             else {

                 Object buttonClicked = request.getParameter(KNSConstants.QUESTION_CLICKED_BUTTON);

                 if ((KNSConstants.DOCUMENT_SAVE_BEFORE_CLOSE_QUESTION.equals(question)) && ConfirmationQuestion.YES.equals(buttonClicked)) {

                     // if yes button clicked - save the doc

                         ActionForward forward = checkAndWarnAboutSensitiveData(mapping, form, request, response, KNSPropertyConstants.DOCUMENT_EXPLANATION, document.getDocumentHeader().getExplanation(), "save", "");

                     if (forward != null) {

                             return forward;

                     }

                                getDocumentService().saveDocument(docForm.getDocument());

                 }

                 // else go to close logic below

             }

         }

         return returnToSender(request, mapping, docForm);

     }

     protected boolean canSave(ActionForm form){

             KualiDocumentFormBase docForm = (KualiDocumentFormBase) form;

             return docForm.getDocumentActions().containsKey(KNSConstants.KUALI_ACTION_CAN_SAVE);

     }

     protected Object getQuestion(HttpServletRequest request){

             return request.getParameter(KNSConstants.QUESTION_INST_ATTRIBUTE_NAME);

     }

     /**

      * call the document service to clear the fyis

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward fyi(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

         getDocumentService().clearDocumentFyi(kualiDocumentFormBase.getDocument(), combineAdHocRecipients(kualiDocumentFormBase));

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_FYIED);

         kualiDocumentFormBase.setAnnotation("");

         return returnToSender(request, mapping, kualiDocumentFormBase);

     }

     /**

      * call the document service to acknowledge

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward acknowledge(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         doProcessingAfterPost( kualiDocumentFormBase, request );

         getDocumentService().acknowledgeDocument(kualiDocumentFormBase.getDocument(), kualiDocumentFormBase.getAnnotation(), combineAdHocRecipients(kualiDocumentFormBase));

         GlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_ROUTE_ACKNOWLEDGED);

         kualiDocumentFormBase.setAnnotation("");

         return returnToSender(request, mapping, kualiDocumentFormBase);

     }

     /**

      * redirect to the supervisor functions that exist.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward supervisorFunctions(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase kualiDocumentFormBase = (KualiDocumentFormBase) form;

         String workflowSuperUserUrl = getKualiConfigurationService().getPropertyString(KNSConstants.WORKFLOW_URL_KEY) + "/SuperUser.do?methodToCall=displaySuperUserDocument&routeHeaderId=" + kualiDocumentFormBase.getDocument().getDocumentHeader().getDocumentNumber();

         response.sendRedirect(workflowSuperUserUrl);

         return null;

     }

     /**

      * Convenience method to combine the two lists of ad hoc recipients into one which should be done before calling any of the

      * document service methods that expect a list of ad hoc recipients

      *

      * @param kualiDocumentFormBase

      * @return List

      */

     protected List<AdHocRouteRecipient> combineAdHocRecipients(KualiDocumentFormBase kualiDocumentFormBase) {

         List<AdHocRouteRecipient> adHocRecipients = new ArrayList<AdHocRouteRecipient>();

         adHocRecipients.addAll(kualiDocumentFormBase.getAdHocRoutePersons());

         adHocRecipients.addAll(kualiDocumentFormBase.getAdHocRouteWorkgroups());

         return adHocRecipients;

     }

     /**

      * if the action desires to retain error messages generated by the rules framework for save/submit/etc. validation after returning from a lookup.

      * @see org.kuali.rice.kns.web.struts.action.KualiAction#refresh(org.apache.struts.action.ActionMapping,

      *      org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)

      */

     @Override

     public ActionForward refresh(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

             KualiDocumentFormBase kualiForm = (KualiDocumentFormBase) form;

                 kualiForm.setDerivedValuesOnForm(request);

         super.refresh(mapping, form, request, response);

         refreshAdHocRoutingWorkgroupLookups(request, kualiForm);

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      * special refresh needed to get the workgroups populated correctly when coming back from workgroup lookups

      *

      * @param request

      * @param kualiForm

      * @throws WorkflowException

      */

     @SuppressWarnings("unchecked")

         protected void refreshAdHocRoutingWorkgroupLookups(HttpServletRequest request, KualiDocumentFormBase kualiForm) throws WorkflowException {

         for (Enumeration<String> i = request.getParameterNames(); i.hasMoreElements();) {

             String parameterName = i.nextElement();

             if (parameterName.equals("newAdHocRouteWorkgroup.recipientName") && !"".equals(request.getParameter(parameterName))) {

                 //check for namespace

                 String namespace = KimConstants.KIM_GROUP_DEFAULT_NAMESPACE_CODE;

                 if (request.getParameter("newAdHocRouteWorkgroup.recipientNamespaceCode") != null && !"".equals(request.getParameter("newAdHocRouteWorkgroup.recipientName").trim())) {

                     namespace = request.getParameter("newAdHocRouteWorkgroup.recipientNamespaceCode").trim();

                 }

                 Group group = getIdentityManagementService().getGroupByName(namespace, request.getParameter(parameterName));

                 if (group != null) {

                     kualiForm.getNewAdHocRouteWorkgroup().setId(group.getGroupId());

                     kualiForm.getNewAdHocRouteWorkgroup().setRecipientName(group.getGroupName());

                     kualiForm.getNewAdHocRouteWorkgroup().setRecipientNamespaceCode(group.getNamespaceCode());

                 } else {

                     throw new RuntimeException("Invalid workgroup id passed as parameter.");

                 }

             }

             if (parameterName.startsWith("adHocRouteWorkgroup[") && !"".equals(request.getParameter(parameterName))) {

                 if (parameterName.endsWith(".recipientName")) {

                     int lineNumber = Integer.parseInt(StringUtils.substringBetween(parameterName, "[", "]"));

                   //check for namespace

                     String namespaceParam = "adHocRouteWorkgroup[" + lineNumber + "].recipientNamespaceCode";

                     String namespace = KimConstants.KIM_GROUP_DEFAULT_NAMESPACE_CODE;

                     if (request.getParameter(namespaceParam) != null && !"".equals(request.getParameter(namespaceParam).trim())) {

                         namespace = request.getParameter(namespaceParam).trim();

                     }

                     Group group = getIdentityManagementService().getGroupByName(namespace, request.getParameter(parameterName));

                     if (group != null) {

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setId(group.getGroupId());

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setRecipientName(group.getGroupName());

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setRecipientNamespaceCode(group.getNamespaceCode());

                     } else {

                         throw new RuntimeException("Invalid workgroup id passed as parameter.");

                     }

                 }

             }

             /*

             if (parameterName.startsWith("newAdHocRouteWorkgroup[") && !"".equals(request.getParameter(parameterName))) {

                 if (parameterName.endsWith(".recipientName")) {

                     int lineNumber = Integer.parseInt(StringUtils.substringBetween(parameterName, "[", "]"));

                   //check for namespace

                     String namespaceParam = "newAdHocRouteWorkgroup[" + lineNumber + "].recipientNamespaceCode";

                     String namespace = KimConstants.KIM_GROUP_DEFAULT_NAMESPACE_CODE;

                     if (request.getParameter(namespaceParam) != null && !"".equals(request.getParameter(namespaceParam).trim())) {

                         namespace = request.getParameter(namespaceParam).trim();

                     }

                     KimGroup group = getIdentityManagementService().getGroupByName(namespace, request.getParameter(parameterName));

                     if (group != null) {

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setId(group.getGroupId());

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setRecipientName(group.getGroupName());

                         kualiForm.getAdHocRouteWorkgroup(lineNumber).setRecipientNamespaceCode(group.getNamespaceCode());

                     } else {

                         throw new RuntimeException("Invalid workgroup id passed as parameter.");

                     }

                 }

             }

             */

         }

     }

     /**

      * Cancels the pending attachment, if any.

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward cancelBOAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form;

         // blank current attachmentFile

         documentForm.setAttachmentFile(new BlankFormFile());

         // remove current attachment, if any

         Note note = documentForm.getNewNote();

         note.removeAttachment();

         documentForm.setNewNote(note);

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**

      *

      * Handy method to stream the byte array to response object

      * @param attachmentDataSource

      * @param response

      * @throws Exception

      */

     protected void streamToResponse(byte[] fileContents, String fileName, String fileContentType,HttpServletResponse response) throws Exception{

         ByteArrayOutputStream baos = null;

         try{

             baos = new ByteArrayOutputStream(fileContents.length);

             baos.write(fileContents);

             WebUtils.saveMimeOutputStreamAsFile(response, fileContentType, baos, fileName);

         }finally{

             try{

                 if(baos!=null){

                     baos.close();

                     baos = null;

                 }

             }catch(IOException ioEx){

                 LOG.error("Error while downloading attachment");

                 throw new RuntimeException("IOException occurred while downloading attachment", ioEx);

             }

         }

     }

     /**

      * Downloads the selected attachment to the user's browser

      *

      * @param mapping

      * @param form

      * @param request

      * @param response

      * @return ActionForward

      * @throws Exception

      */

     public ActionForward downloadBOAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

         int attachmentIndex = selectedAttachmentIndex(request);

         Note newNote = ((KualiDocumentFormBase) form).getNewNote();

         PersistableBusinessObject noteParent = getNoteParent(((KualiDocumentFormBase) form).getDocument(), newNote);

         if (attachmentIndex >= 0) {

             Note note = noteParent.getBoNote(attachmentIndex);

             Attachment attachment = note.getAttachment();

             //make sure attachment is setup with backwards reference to note (rather then doing this we could also just call the attachment service (with a new method that took in the note)

             attachment.setNote(note);

             // since we're downloading a file, all of the editable properties from the previous request will continue to be editable.

             KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form;

             documentForm.copyPopulateEditablePropertiesToActionEditableProperties();

             WebUtils.saveMimeInputStreamAsFile(response, attachment.getAttachmentMimeTypeCode(), attachment.getAttachmentContents(), attachment.getAttachmentFileName(), attachment.getAttachmentFileSize().intValue());

             return null;

         }

         return mapping.findForward(RiceConstants.MAPPING_BASIC);

     }

     /**