/**
 * Copyright 2005-2014 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.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.log4j.MDC;
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.CoreApiServiceLocator;
import org.kuali.rice.core.api.config.property.ConfigurationService;
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.util.GlobalVariables;
import org.kuali.rice.krad.util.KRADConstants;
import org.kuali.rice.krad.util.KRADUtils;
import org.kuali.rice.krad.util.LegacyUtils;
import org.kuali.rice.krad.util.MessageMap;
import org.springframework.dao.OptimisticLockingFailureException;
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.
 *
 * @deprecated KNS Struts deprecated, use KRAD and the Spring MVC framework.
 */
@Deprecated
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(final HttpServletRequest request,
                        final HttpServletResponse response) throws IOException, ServletException {
        // indicates that we are running in legacy KNS context
        LegacyUtils.beginLegacyContext();
        try {
            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);
            }
        } finally {
            LegacyUtils.endLegacyContext();
        }
    }

    @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
            ActionForward forward = processActionPerform(request, response, action, form, mapping);

            if (forward != null) {
                if (forward.getRedirect() && forward.getName()!= null && forward.getName().equals(KRADConstants.KRAD_INITIATED_DOCUMENT_VIEW_NAME)) {
                    LOG.info("Attempt to open a document with a status of \"Initiated\" detected");
                    return;
                }
                // ProcessDefinition the returned ActionForward instance
                processForwardConfig(request, response, forward);
            }
        }
    }


    /**
     * 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() {
                    public Object doInTransaction(TransactionStatus status) {
                        ActionForward actionForward = null;
                        try {
                            actionForward = action.execute(mapping, form, request, response);
                        } catch (Exception e) {
                            if (e.getMessage()!= null && e.getMessage().equals(KRADConstants.KRAD_INITIATED_DOCUMENT_VIEW_NAME)) {
                                ConfigurationService kualiConfigurationService = CoreApiServiceLocator
                                        .getKualiConfigurationService();
                                StringBuffer sb = new StringBuffer();
                                sb.append(kualiConfigurationService.getPropertyValueAsString(KRADConstants.KRAD_URL_KEY));
                                sb.append(kualiConfigurationService.getPropertyValueAsString(KRADConstants.KRAD_INITIATED_DOCUMENT_URL_KEY));
                                return new ActionForward(KRADConstants.KRAD_INITIATED_DOCUMENT_VIEW_NAME, sb.toString() ,true);
                            }
                            // 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 != null ) {
                    Object sourceObject = null;
                    boolean optLockException = false;
                    if ( subcause instanceof javax.persistence.OptimisticLockException ) {
                        javax.persistence.OptimisticLockException ole = (javax.persistence.OptimisticLockException) subcause;
                        sourceObject = ole.getEntity();
                        optLockException = true;
                    } else if ( subcause instanceof OptimisticLockingFailureException ) {
                        OptimisticLockingFailureException ole = (OptimisticLockingFailureException) subcause;
                        sourceObject = ole.getMessage();
                        optLockException = true;
                    } else {
                        if ( subcause.getClass().getName().equals( "org.apache.ojb.broker.OptimisticLockException" ) ) {
                            try {
                                sourceObject = PropertyUtils.getSimpleProperty(subcause, "sourceObject");
                            } catch (Exception ex) {
                                LOG.warn( "Unable to retrieve source object from OJB OptimisticLockException", ex );
                            }
                            optLockException = true;
                        }
                    }
                    if ( optLockException ) {
                        StringBuilder message = new StringBuilder(e.getMessage());

                        if (sourceObject != null) {
                            if ( sourceObject instanceof String ) {
                                message.append(" Embedded Message: ").append( sourceObject );
                            } else {
                                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 (!GlobalVariables.getAuditErrorMap().isEmpty()) {
            request.setAttribute(KNSConstants.AUDIT_ERRORS, GlobalVariables.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 = KNSServiceLocator.getTransactionManager();
        }
        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;
    }
}