/**
    * Copyright 2005-2012 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.IOException;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.apache.log4j.MDC;
  import org.apache.ojb.broker.OptimisticLockException;
  import org.apache.struts.Globals;
  import org.apache.struts.action.Action;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  import org.apache.struts.action.InvalidCancelException;
  import org.apache.struts.action.RequestProcessor;
  import org.apache.struts.config.FormBeanConfig;
  import org.apache.struts.config.ForwardConfig;
  import org.apache.struts.util.RequestUtils;
  import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
  import org.kuali.rice.core.api.util.RiceConstants;
  import org.kuali.rice.core.api.util.RiceKeyConstants;
  import org.kuali.rice.kns.exception.FileUploadLimitExceededException;
  import org.kuali.rice.kns.service.KNSServiceLocator;
  import org.kuali.rice.kns.service.SessionDocumentService;
  import org.kuali.rice.kns.util.ErrorContainer;
  import org.kuali.rice.kns.util.InfoContainer;
  import org.kuali.rice.kns.util.KNSConstants;
  import org.kuali.rice.kns.util.KNSGlobalVariables;
  import org.kuali.rice.kns.util.WarningContainer;
  import org.kuali.rice.kns.util.WebUtils;
  import org.kuali.rice.kns.web.EditablePropertiesHistoryHolder;
  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.pojo.PojoForm;
  import org.kuali.rice.krad.UserSession;
  import org.kuali.rice.krad.document.Document;
  import org.kuali.rice.krad.exception.ValidationException;
  import org.kuali.rice.krad.service.KRADServiceLocatorInternal;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.KRADConstants;
  import org.kuali.rice.krad.util.KRADUtils;
  import org.kuali.rice.krad.util.MessageMap;
  import org.springframework.transaction.PlatformTransactionManager;
  import org.springframework.transaction.TransactionStatus;
  import org.springframework.transaction.support.TransactionCallback;
  import org.springframework.transaction.support.TransactionTemplate;
  import org.springmodules.orm.ojb.OjbOperationException;
  
  /**
   * This class handles setup of user session and restoring of action form.
   *
   *
   */
  public class KualiRequestProcessor extends RequestProcessor {
  
  	private static final String MDC_DOC_ID = "docId";
  	private static final String PREVIOUS_REQUEST_EDITABLE_PROPERTIES_GUID_PARAMETER_NAME = "actionEditablePropertiesGuid";
  
  	private static Logger LOG = Logger.getLogger(KualiRequestProcessor.class);
  
  	private SessionDocumentService sessionDocumentService;
  	private PlatformTransactionManager transactionManager;
  
  	@Override
  	public void process(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
  		if ( LOG.isInfoEnabled() ) {
  			LOG.info(new StringBuffer("Started processing request: '").append(request.getRequestURI()).append("' w/ query string: '").append(request.getQueryString()).append("'"));
  		}
  
  		try {
  			strutsProcess(request, response);
  		} catch (FileUploadLimitExceededException e) {
  			ActionForward actionForward = processException(request, response, e, e.getActionForm(), e.getActionMapping());
  			processForwardConfig(request, response, actionForward);
  		} finally {
  			KNSGlobalVariables.setKualiForm(null);
  		}
  
  		try {
 			ActionForm form = WebUtils.getKualiForm(request);
 
 			if (form != null && form instanceof KualiDocumentFormBase) {
 				String docId = ((KualiDocumentFormBase) form).getDocId();
 				if (docId != null) { MDC.put(MDC_DOC_ID, docId); }
 			}
 
 			String refreshCaller = request.getParameter(KRADConstants.REFRESH_CALLER);
 			if (form!=null && KualiDocumentFormBase.class.isAssignableFrom(form.getClass())
 					&& !KRADConstants.QUESTION_REFRESH.equalsIgnoreCase(refreshCaller)) {
 				KualiDocumentFormBase docForm = (KualiDocumentFormBase) form;
 				Document document = docForm.getDocument();
 				String docFormKey = docForm.getFormKey();
 
 				UserSession userSession = (UserSession) request.getSession().getAttribute(KRADConstants.USER_SESSION_KEY);
 
 				if (WebUtils.isDocumentSession(document, docForm)) {
 					getSessionDocumentService().setDocumentForm(docForm, userSession, request.getRemoteAddr());
 				}
 
 				Boolean exitingDocument = (Boolean) request.getAttribute(KRADConstants.EXITING_DOCUMENT);
 
 				if (exitingDocument != null && exitingDocument.booleanValue()) {
 					// remove KualiDocumentFormBase object from session and
 					// table.
 					getSessionDocumentService().purgeDocumentForm(docForm.getDocument().getDocumentNumber(), docFormKey, userSession, request.getRemoteAddr());
 				}
 			}
 
 			if ( LOG.isInfoEnabled() ) {
 				LOG.info(new StringBuffer("Finished processing request: '").append(request.getRequestURI()).append("' w/ query string: '").append(request.getQueryString()).append("'"));
 			}
 
 		} finally {
 			// MDC docId key is set above, and also during super.process() in the call to processActionForm
 			MDC.remove(MDC_DOC_ID);
 		}
 
 	}
 
 	@Override
 	protected boolean processPreprocess(HttpServletRequest request, HttpServletResponse response) {
         final UserSession session = KRADUtils.getUserSessionFromRequest(request);
 
         if (session == null) {
         	throw new IllegalStateException("the user session has not been established");
         }
     	GlobalVariables.setUserSession(session);
     	KNSGlobalVariables.clear();
 		return true;
 	}
 
 	/**
      * <p>ProcessDefinition an <code>HttpServletRequest</code> and create the
      * corresponding <code>HttpServletResponse</code> or dispatch
      * to another resource.</p>
      *
      * @param request The servlet request we are processing
      * @param response The servlet response we are creating
      *
      * @exception IOException if an input/output error occurs
      * @exception ServletException if a processing exception occurs
      */
     public void strutsProcess(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
 
         // Wrap multipart requests with a special wrapper
         request = processMultipart(request);
 
         // Identify the path component we will use to select a mapping
         String path = processPath(request, response);
         if (path == null) {
             return;
         }
 
         if (log.isDebugEnabled()) {
             log.debug("Processing a '" + request.getMethod() +
                       "' for path '" + path + "'");
         }
 
         // Select a Locale for the current user if requested
         processLocale(request, response);
 
         // Set the content type and no-caching headers if requested
         processContent(request, response);
         processNoCache(request, response);
 
         // General purpose preprocessing hook
         if (!processPreprocess(request, response)) {
             return;
         }
 
         this.processCachedMessages(request, response);
 
         // Identify the mapping for this request
         ActionMapping mapping = processMapping(request, response, path);
         if (mapping == null) {
             return;
         }
 
         // Check for any role required to perform this action
         if (!processRoles(request, response, mapping)) {
             return;
         }
 
         processFormActionAndForward(request, response, mapping);
 
     }
 
     public void processFormActionAndForward(final HttpServletRequest request, final HttpServletResponse response, final ActionMapping mapping) throws ServletException, IOException {
         ActionForm form = processActionForm(request, response, mapping);
         processPopulate(request, response, form, mapping);
 
         // Create or acquire the Action instance to process this request
         Action action = processActionCreate(request, response, mapping);
 
         if (action != null) {
             // Call the Action instance itself
             final ActionForward forward = processActionPerform(request, response, action, form, mapping);
 
             if (forward != null) {
                 // ProcessDefinition the returned ActionForward instance
                 TransactionTemplate template = new TransactionTemplate(getTransactionManager());
                 try {
                     template.execute(new TransactionCallback<Object>() {
                         @Override
                         public Object doInTransaction(TransactionStatus status) {
                             try {
                                 processForwardConfig(request, response, forward);
                             }
                             catch (IOException ex) {
                                 throw new RuntimeException(ex);
                             }
                             catch (ServletException ex) {
                                 throw new RuntimeException(ex);
                             }
                             return null;
                         }
                     });
                 } catch ( RuntimeException ex ) {
                     if ( ex.getCause() instanceof IOException ) {
                         throw (IOException)ex.getCause();
                     } else if ( ex.getCause() instanceof ServletException ) {
                         throw (ServletException)ex.getCause();
                     }
                     throw ex;
                 }
             }
         }
     }
 
 
 	/**
 	 * This method gets the document number from the request.  The request should have been processed already
 	 * before this is called if it is multipart.
 	 *
 	 * @param request
 	 * @return the document number, or null if one can't be found in the request.
 	 */
 	private String getDocumentNumber(HttpServletRequest request) {
 		String documentNumber = request.getParameter(KRADConstants.DOCUMENT_DOCUMENT_NUMBER);
 
 		// from lookup pages.
 		if (documentNumber == null) {
 			documentNumber = request.getParameter(KRADConstants.DOC_NUM);
 		}
 
 		if (documentNumber == null) {
 			documentNumber = request.getParameter("documentId");
 		}
 
 		return documentNumber;
 	}
 
 	/**
 	 * Hooks into populate process to call form populate method if form is an
 	 * instanceof PojoForm.
 	 */
 	@Override
 	protected void processPopulate(HttpServletRequest request, HttpServletResponse response, ActionForm form, ActionMapping mapping) throws ServletException {
 		if (form instanceof KualiForm) {
 			// Add the ActionForm to GlobalVariables
 			// This will allow developers to retrieve both the Document and any
 			// request parameters that are not
 			// part of the Form and make them available in ValueFinder classes
 			// and other places where they are needed.
 			KNSGlobalVariables.setKualiForm((KualiForm) form);
 		}
 
 		// if not PojoForm, call struts populate
 		if (!(form instanceof PojoForm)) {
 			super.processPopulate(request, response, form, mapping);
 			return;
 		}
 
 		final String previousRequestGuid = request.getParameter(KualiRequestProcessor.PREVIOUS_REQUEST_EDITABLE_PROPERTIES_GUID_PARAMETER_NAME);
 
 		((PojoForm)form).clearEditablePropertyInformation();
 		((PojoForm)form).registerStrutsActionMappingScope(mapping.getScope());
 
 		String multipart = mapping.getMultipartClass();
 		if (multipart != null) {
 			request.setAttribute(Globals.MULTIPART_KEY, multipart);
 		}
 
 		form.setServlet(this.servlet);
 		form.reset(mapping, request);
 
 		((PojoForm)form).setPopulateEditablePropertiesGuid(previousRequestGuid);
 		// call populate on ActionForm
 		((PojoForm) form).populate(request);
 		request.setAttribute("UnconvertedValues", ((PojoForm) form).getUnconvertedValues().keySet());
 		request.setAttribute("UnconvertedHash", ((PojoForm) form).getUnconvertedValues());
 	}
 
 	/**
 	 * Hooks into validate to catch any errors from the populate, and translate
 	 * the ErrorMap to ActionMessages.
 	 */
 	@Override
 	protected boolean processValidate(HttpServletRequest request, HttpServletResponse response, ActionForm form, ActionMapping mapping) throws IOException, ServletException, InvalidCancelException {
 
 		// skip form validate if we had errors from populate
 		if (GlobalVariables.getMessageMap().hasNoErrors()) {
 			if (form == null) {
 				return (true);
 			}
 			// Was this request cancelled?
 			if (request.getAttribute(Globals.CANCEL_KEY) != null) {
 				if (LOG.isDebugEnabled()) {
 					LOG.debug(" Cancelled transaction, skipping validation");
 				}
 				return (true);
 			}
 
 			// Has validation been turned off for this mapping?
 			if (!mapping.getValidate()) {
 				return (true);
 			}
 
 			// call super to call forms validate
 			super.processValidate(request, response, form, mapping);
 		}
 
 		publishMessages(request);
 		if (!GlobalVariables.getMessageMap().hasNoErrors()) {
 			// Special handling for multipart request
 			if (form.getMultipartRequestHandler() != null) {
 				if (LOG.isDebugEnabled()) {
 					LOG.debug("  Rolling back multipart request");
 				}
 				form.getMultipartRequestHandler().rollback();
 			}
 
 			// Fix state that could be incorrect because of validation failure
 			if (form instanceof PojoForm) {
 				((PojoForm) form).processValidationFail();
 			}
 
 			// Was an input path (or forward) specified for this mapping?
 			String input = mapping.getInput();
 			if (input == null) {
 				if (LOG.isDebugEnabled()) {
 					LOG.debug("  Validation failed but no input form available");
 				}
 				response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, getInternal().getMessage("noInput", mapping.getPath()));
 				return (false);
 			}
 
 			if (moduleConfig.getControllerConfig().getInputForward()) {
 				ForwardConfig forward = mapping.findForward(input);
 				processForwardConfig(request, response, forward);
 			} else {
 				internalModuleRelativeForward(input, request, response);
 			}
 
 			return (false);
 		}
 		return true;
 	}
 
 	/**
 	 * Checks for return from a lookup or question, and restores the action form
 	 * stored under the request parameter docFormKey.
 	 */
 	@Override
 	protected ActionForm processActionForm(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) {
 
 		String documentNumber = getDocumentNumber(request);
 		if (documentNumber != null) { MDC.put(MDC_DOC_ID, documentNumber); }
 
 		UserSession userSession = (UserSession) request.getSession().getAttribute(KRADConstants.USER_SESSION_KEY);
 
 		String docFormKey = request.getParameter(KRADConstants.DOC_FORM_KEY);
 		String methodToCall = request.getParameter(KRADConstants.DISPATCH_REQUEST_PARAMETER);
 		String refreshCaller = request.getParameter(KRADConstants.REFRESH_CALLER);
 //		String searchListRequestKey = request.getParameter(KRADConstants.SEARCH_LIST_REQUEST_KEY);
 		String documentWebScope = request.getParameter(KRADConstants.DOCUMENT_WEB_SCOPE);
 
 		if (mapping.getPath().startsWith(KRADConstants.REFRESH_MAPPING_PREFIX) || KRADConstants.RETURN_METHOD_TO_CALL.equalsIgnoreCase(methodToCall) ||
 				KRADConstants.QUESTION_REFRESH.equalsIgnoreCase(refreshCaller) || KRADConstants.TEXT_AREA_REFRESH.equalsIgnoreCase(refreshCaller) || KRADConstants
                 .SESSION_SCOPE.equalsIgnoreCase(documentWebScope)) {
 			ActionForm form = null;
 			// check for search result storage and clear
 			GlobalVariables.getUserSession().removeObjectsByPrefix(KRADConstants.SEARCH_LIST_KEY_PREFIX);
 
 			// We put different type of forms such as document form, lookup form
 			// in session but we only store document form in
 			// database.
 			if (userSession.retrieveObject(docFormKey) != null) {
 				LOG.debug("getDecomentForm KualiDocumentFormBase from session");
 				form = (ActionForm) userSession.retrieveObject(docFormKey);
 			} else if (StringUtils.isNotBlank(documentNumber)) {
 				form = getSessionDocumentService().getDocumentForm(documentNumber, docFormKey, userSession, request.getRemoteAddr());
 			}
 			request.setAttribute(mapping.getAttribute(), form);
 			if (!KRADConstants.SESSION_SCOPE.equalsIgnoreCase(documentWebScope)) {
 				userSession.removeObject(docFormKey);
 			}
 			// we should check whether this is a multipart request because we
 			// could have had a combination of query parameters and a multipart
 			// request
 			String contentType = request.getContentType();
 			String method = request.getMethod();
 			if (("POST".equalsIgnoreCase(method) && contentType != null && contentType.startsWith("multipart/form-data"))) {
 				// this method parses the multipart request and adds new
 				// non-file parameters into the request
 				WebUtils.getMultipartParameters(request, null, form, mapping);
 			}
 			// The form can be null if the document is not a session document
 			if (form != null) {
 				return form;
 			}
 		}
 
 		// Rice has the ability to limit file upload sizes on a per-form basis,
 		// so the max upload sizes may be accessed by calling methods on
 		// PojoFormBase.
 		// This requires that we are able know the file upload size limit (i.e.
 		// retrieve a form instance) before we parse a mulitpart request.
 		ActionForm form = super.processActionForm(request, response, mapping);
 
 		// for sessiondocument with multipart request
 		String contentType = request.getContentType();
 		String method = request.getMethod();
 
 		if ("GET".equalsIgnoreCase(method) && StringUtils.isNotBlank(methodToCall) && form instanceof PojoForm &&
 				((PojoForm) form).getMethodToCallsToBypassSessionRetrievalForGETRequests().contains(methodToCall)) {
 			return createNewActionForm(mapping, request);
 		}
 
 		// if we have a multipart request, parse it and return the stored form
 		// from session if the doc form key is not blank. If it is blank, then
 		// we just return the form
 		// generated from the superclass processActionForm method. Either way,
 		// we need to parse the mulitpart request now so that we may determine
 		// what the value of the doc form key is.
 		// This is generally against the contract of processActionForm, because
 		// processPopulate should be responsible for parsing the mulitpart
 		// request, but we need to parse it now
 		// to determine the doc form key value.
 		if (("POST".equalsIgnoreCase(method) && contentType != null && contentType.startsWith("multipart/form-data"))) {
 			WebUtils.getMultipartParameters(request, null, form, mapping);
 			docFormKey = request.getParameter(KRADConstants.DOC_FORM_KEY);
 			documentWebScope = request.getParameter(KRADConstants.DOCUMENT_WEB_SCOPE);
 
 			documentNumber = getDocumentNumber(request);
 
 			if (KRADConstants.SESSION_SCOPE.equalsIgnoreCase(documentWebScope) ||
 					(form instanceof KualiDocumentFormBase && WebUtils
                             .isDocumentSession(((KualiDocumentFormBase) form).getDocument(),
                                     (KualiDocumentFormBase) form))) {
 
 				Object userSessionObject = userSession.retrieveObject(docFormKey);
 				if ( userSessionObject != null &&  userSessionObject instanceof ActionForm ) {
 					LOG.debug("getDocumentForm KualiDocumentFormBase from session");
 					form = (ActionForm) userSessionObject;
 				} else {
 					ActionForm tempForm = getSessionDocumentService().getDocumentForm(documentNumber, docFormKey, userSession, request.getRemoteAddr());
 					if ( tempForm != null ) {
 						form = tempForm;
 					}
 				}
 
 				request.setAttribute(mapping.getAttribute(), form);
 				if (form != null) {
 					return form;
 				}
 			}
 		}
 		return form;
 	}
 
 	/**
 	 * Hook into action perform to handle errors in the error map and catch
 	 * exceptions.
 	 *
 	 * <p>
 	 * A transaction is started prior to the execution of the action. This
 	 * allows for the action code to execute efficiently without the need for
 	 * using PROPAGATION_SUPPORTS in the transaction definitions. The
 	 * PROPAGATION_SUPPORTS propagation type does not work well with JTA.
 	 */
 	@Override
 	protected ActionForward processActionPerform(final HttpServletRequest request, final HttpServletResponse response, final Action action, final ActionForm form, final ActionMapping mapping) throws IOException, ServletException {
 		try {
             TransactionTemplate template = new TransactionTemplate(getTransactionManager());
 			ActionForward forward = null;
 			try {
 				forward = (ActionForward) template.execute(new TransactionCallback() {
 					@Override
                     public Object doInTransaction(TransactionStatus status) {
 						ActionForward actionForward = null;
 						try {
 							actionForward = action.execute(mapping, form, request, response);
 						} catch (Exception e) {
 							// the doInTransaction method has no means for
 							// throwing exceptions, so we will wrap the
 							// exception in
 							// a RuntimeException and re-throw. The one caveat
 							// here is that this will always result in
 							// the
 							// transaction being rolled back (since
 							// WrappedRuntimeException is a runtime exception).
 							throw new WrappedRuntimeException(e);
 						}
 						if (status.isRollbackOnly()) {
 							// this means that the struts action execution
 							// caused the transaction to rollback, we want to
 							// go ahead
 							// and trigger the rollback by throwing an exception
 							// here but then return the action forward
 							// from this method
 							throw new WrappedActionForwardRuntimeException(actionForward);
 						}
 						return actionForward;
 					}
 				});
 			} catch (WrappedActionForwardRuntimeException e) {
 				forward = e.getActionForward();
 			}
 
 			publishMessages(request);
 			saveMessages(request);
 			saveAuditErrors(request);
 
 			if (form instanceof PojoForm) {
 				if (((PojoForm)form).getEditableProperties() == null
 						|| ((PojoForm)form).getEditableProperties().isEmpty()) {
 					EditablePropertiesHistoryHolder holder = (EditablePropertiesHistoryHolder) GlobalVariables.getUserSession().getObjectMap().get(
                             KRADConstants.EDITABLE_PROPERTIES_HISTORY_HOLDER_ATTR_NAME);
 				    if (holder == null) {
 				    	holder = new EditablePropertiesHistoryHolder();
 				    }
 
 					final String guid = holder.addEditablePropertiesToHistory(((PojoForm)form).getEditableProperties());
 				    ((PojoForm)form).setActionEditablePropertiesGuid(guid);
 				    GlobalVariables.getUserSession().addObject(KRADConstants.EDITABLE_PROPERTIES_HISTORY_HOLDER_ATTR_NAME, holder);
 				}
 			}
 
 			return forward;
 
 		} catch (Exception e) {
 			if (e instanceof WrappedRuntimeException) {
 				e = (Exception) e.getCause();
 			}
 			if (e instanceof ValidationException) {
 				// add a generic error message if there are none
 				if (GlobalVariables.getMessageMap().hasNoErrors()) {
 
 					GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_ERRORS, RiceKeyConstants.ERROR_CUSTOM, e.getMessage());
 				}
 
 				if (form instanceof PojoForm) {
 					if (((PojoForm)form).getEditableProperties() == null
 							|| ((PojoForm)form).getEditableProperties().isEmpty()) {
 					    EditablePropertiesHistoryHolder holder = (EditablePropertiesHistoryHolder) GlobalVariables.getUserSession().getObjectMap().get(
                                 KRADConstants.EDITABLE_PROPERTIES_HISTORY_HOLDER_ATTR_NAME);
 				        if (holder == null) {
 				    	    holder = new EditablePropertiesHistoryHolder();
 				        }
 
 					    final String guid = holder.addEditablePropertiesToHistory(((PojoForm)form).getEditableProperties());
 				        ((PojoForm)form).setActionEditablePropertiesGuid(guid);
 				        GlobalVariables.getUserSession().addObject(KRADConstants.EDITABLE_PROPERTIES_HISTORY_HOLDER_ATTR_NAME, holder);
 					}
 				}
 				// display error messages and return to originating page
 				publishMessages(request);
 				return mapping.findForward(RiceConstants.MAPPING_BASIC);
 			}
 
 			publishMessages(request);
 
 			return (processException(request, response, e, form, mapping));
 		}
 	}
 
     private static class WrappedActionForwardRuntimeException extends RuntimeException {
 		private ActionForward actionForward;
 
 		public WrappedActionForwardRuntimeException(ActionForward actionForward) {
 			this.actionForward = actionForward;
 		}
 
 		public ActionForward getActionForward() {
 			return actionForward;
 		}
 	}
 
 	/**
 	 * Adds more detailed logging for unhandled exceptions
 	 *
 	 * @see org.apache.struts.action.RequestProcessor#processException(HttpServletRequest,
 	 *      HttpServletResponse, Exception, ActionForm, ActionMapping)
 	 */
 	@Override
 	protected ActionForward processException(HttpServletRequest request, HttpServletResponse response, Exception exception, ActionForm form, ActionMapping mapping) throws IOException, ServletException {
 		ActionForward actionForward = null;
 
 		try {
 			actionForward = super.processException(request, response, exception, form, mapping);
 		} catch (IOException e) {
 			logException(e);
 			throw e;
 		} catch (ServletException e) {
 			// special case, to make OptimisticLockExceptions easier to read
 			Throwable rootCause = e.getRootCause();
 			if (rootCause instanceof OjbOperationException) {
 				OjbOperationException ooe = (OjbOperationException) rootCause;
 
 				Throwable subcause = ooe.getCause();
 				if (subcause instanceof OptimisticLockException) {
 					OptimisticLockException ole = (OptimisticLockException) subcause;
 
 					StringBuffer message = new StringBuffer(e.getMessage());
 
 					Object sourceObject = ole.getSourceObject();
 					if (sourceObject != null) {
 						message.append(" (sourceObject is ");
 						message.append(sourceObject.getClass().getName());
 						message.append(")");
 					}
 
 					e = new ServletException(message.toString(), rootCause);
 				}
 			}
 
 			logException(e);
 			throw e;
 		}
 		return actionForward;
 	}
 
 	private void logException(Exception e) {
 		LOG.error("unhandled exception thrown by KualiRequestProcessor.processActionPerform", e);
 	}
 
 	/**
 	 * Checks for errors in the error map and transforms them to struts action
 	 * messages then stores in the request.
 	 */
 	private void publishMessages(HttpServletRequest request) {
 		MessageMap errorMap = GlobalVariables.getMessageMap();
 		if (!errorMap.hasNoErrors()) {
 			ErrorContainer errorContainer = new ErrorContainer(errorMap);
 
 			request.setAttribute("ErrorContainer", errorContainer);
 			request.setAttribute(Globals.ERROR_KEY, errorContainer.getRequestErrors());
 			request.setAttribute("ErrorPropertyList", errorContainer.getErrorPropertyList());
 		}
 
 		if (errorMap.hasWarnings()) {
 			WarningContainer warningsContainer = new WarningContainer(errorMap);
 
 			request.setAttribute("WarningContainer", warningsContainer);
 			request.setAttribute("WarningActionMessages", warningsContainer.getRequestMessages());
 			request.setAttribute("WarningPropertyList", warningsContainer.getMessagePropertyList());
 		}
 
 		if (errorMap.hasInfo()) {
 			InfoContainer infoContainer = new InfoContainer(errorMap);
 
 			request.setAttribute("InfoContainer", infoContainer);
 			request.setAttribute("InfoActionMessages", infoContainer.getRequestMessages());
 			request.setAttribute("InfoPropertyList", infoContainer.getMessagePropertyList());
 		}
 	}
 
 	/**
 	 * Checks for messages in GlobalVariables and places list in request
 	 * attribute.
 	 */
 	private void saveMessages(HttpServletRequest request) {
 		if (!KNSGlobalVariables.getMessageList().isEmpty()) {
 			request.setAttribute(KRADConstants.GLOBAL_MESSAGES, KNSGlobalVariables.getMessageList().toActionMessages());
 		}
 	}
 
 	/**
 	 * Checks for messages in GlobalVariables and places list in request
 	 * attribute.
 	 */
 	private void saveAuditErrors(HttpServletRequest request) {
 		if (!KNSGlobalVariables.getAuditErrorMap().isEmpty()) {
 			request.setAttribute(KNSConstants.AUDIT_ERRORS, KNSGlobalVariables.getAuditErrorMap());
 		}
 	}
 
 	/**
 	 * A simple exception that allows us to wrap an exception that is thrown out
 	 * of a transaction template.
 	 */
 	@SuppressWarnings("serial")
 	private static class WrappedRuntimeException extends RuntimeException {
 		public WrappedRuntimeException(Exception e) {
 			super(e);
 		}
 	}
 
 	/**
 	 * @return the sessionDocumentService
 	 */
 	public SessionDocumentService getSessionDocumentService() {
 		if ( sessionDocumentService == null ) {
 			sessionDocumentService = KNSServiceLocator.getSessionDocumentService();
 		}
 		return this.sessionDocumentService;
 	}
 
 	/**
 	 * @return the transactionManager
 	 */
 	public PlatformTransactionManager getTransactionManager() {
 		if ( transactionManager == null ) {
 			transactionManager = GlobalResourceLoader.getService("transactionManager");
 		}
 		return this.transactionManager;
 	}
 
 	private ActionForm createNewActionForm(ActionMapping mapping, HttpServletRequest request) {
         String name = mapping.getName();
         FormBeanConfig config = moduleConfig.findFormBeanConfig(name);
         if (config == null) {
             log.warn("No FormBeanConfig found under '" + name + "'");
             return (null);
         }
         ActionForm instance = RequestUtils.createActionForm(config, servlet);
         if ("request".equals(mapping.getScope())) {
             request.setAttribute(mapping.getAttribute(), instance);
         } else {
             HttpSession session = request.getSession();
             session.setAttribute(mapping.getAttribute(), instance);
         }
         return instance;
 	}
 }