Java tutorial
/** * 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 org.apache.commons.beanutils.PropertyUtils; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.StringUtils; import org.apache.ojb.broker.metadata.ClassNotPersistenceCapableException; 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.api.CoreApiServiceLocator; import org.kuali.rice.core.api.encryption.EncryptionService; import org.kuali.rice.core.api.util.ClassLoaderUtils; import org.kuali.rice.core.api.util.RiceConstants; import org.kuali.rice.core.api.util.RiceKeyConstants; import org.kuali.rice.core.api.util.io.SerializationUtils; import org.kuali.rice.core.web.format.Formatter; import org.kuali.rice.kew.api.KewApiConstants; import org.kuali.rice.kim.api.identity.Person; import org.kuali.rice.kns.datadictionary.MaintainableCollectionDefinition; import org.kuali.rice.kns.datadictionary.MaintenanceDocumentEntry; import org.kuali.rice.kns.document.MaintenanceDocument; import org.kuali.rice.kns.document.MaintenanceDocumentBase; import org.kuali.rice.kns.document.authorization.MaintenanceDocumentAuthorizer; import org.kuali.rice.kns.document.authorization.MaintenanceDocumentRestrictions; import org.kuali.rice.kns.lookup.LookupResultsService; import org.kuali.rice.kns.maintenance.Maintainable; import org.kuali.rice.kns.rule.event.KualiAddLineEvent; import org.kuali.rice.kns.service.KNSServiceLocator; import org.kuali.rice.kns.service.MaintenanceDocumentDictionaryService; import org.kuali.rice.kns.util.KNSGlobalVariables; import org.kuali.rice.kns.util.MaintenanceUtils; import org.kuali.rice.kns.util.WebUtils; 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.krad.bo.DocumentAttachment; import org.kuali.rice.krad.bo.MultiDocumentAttachment; import org.kuali.rice.krad.bo.PersistableAttachment; import org.kuali.rice.krad.bo.PersistableAttachmentList; import org.kuali.rice.krad.bo.PersistableBusinessObject; import org.kuali.rice.krad.exception.DocumentTypeAuthorizationException; import org.kuali.rice.krad.service.KRADServiceLocatorWeb; import org.kuali.rice.krad.service.LookupService; import org.kuali.rice.krad.util.GlobalVariables; import org.kuali.rice.krad.util.KRADConstants; import org.kuali.rice.krad.util.KRADPropertyConstants; import org.kuali.rice.krad.util.ObjectUtils; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.security.GeneralSecurityException; import java.util.ArrayList; import java.util.Collection; import java.util.Enumeration; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; /** * This class handles actions for maintenance documents. These include creating new edit, and copying of maintenance records. * * @deprecated Use {@link org.kuali.rice.krad.maintenance.MaintenanceDocumentController}. */ @Deprecated public class KualiMaintenanceDocumentAction extends KualiDocumentActionBase { protected static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger .getLogger(KualiMaintenanceDocumentAction.class); protected MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService = null; protected EncryptionService encryptionService; protected LookupService lookupService; protected LookupResultsService lookupResultsService; public KualiMaintenanceDocumentAction() { super(); maintenanceDocumentDictionaryService = KNSServiceLocator.getMaintenanceDocumentDictionaryService(); encryptionService = CoreApiServiceLocator.getEncryptionService(); } @Override public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { request.setAttribute(KRADConstants.PARAM_MAINTENANCE_VIEW_MODE, KRADConstants.PARAM_MAINTENANCE_VIEW_MODE_MAINTENANCE); return super.execute(mapping, form, request, response); } /** * Calls setup Maintenance for new action. */ public ActionForward start(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { request.setAttribute(KRADConstants.MAINTENANCE_ACTN, KRADConstants.MAINTENANCE_NEW_ACTION); return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_NEW_ACTION); } /** * Calls setupMaintenance for copy action. */ public ActionForward copy(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { // check for copy document number if (request.getParameter("document." + KRADPropertyConstants.DOCUMENT_NUMBER) == null) { // object copy return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_COPY_ACTION); } else { // document copy throw new UnsupportedOperationException("System does not support copying of maintenance documents."); } } /** * Calls setupMaintenance for edit action. */ public ActionForward edit(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_EDIT_ACTION); } /** * KUALRice 3070 Calls setupMaintenance for delete action. */ public ActionForward delete(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { if (isFormRepresentingLockObject((KualiDocumentFormBase) form)) { return super.delete(mapping, form, request, response); } KNSGlobalVariables.getMessageList().add(RiceKeyConstants.MESSAGE_DELETE); return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_DELETE_ACTION); } /** * Calls setupMaintenance for new object that have existing objects attributes. */ public ActionForward newWithExisting(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_NEWWITHEXISTING_ACTION); } /** * Gets a new document for a maintenance record. The maintainable is specified with the documentTypeName or business object * class request parameter and request parameters are parsed for key values for retrieving the business object. Forward to the * maintenance jsp which renders the page based on the maintainable's field specifications. Retrieves an existing business * object for edit and copy. Checks locking on edit. */ protected ActionForward setupMaintenance(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String maintenanceAction) throws Exception { KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) form; MaintenanceDocument document = null; // create a new document object, if required (on NEW object, or other reasons) if (maintenanceForm.getDocument() == null) { if (StringUtils.isEmpty(maintenanceForm.getBusinessObjectClassName()) && StringUtils.isEmpty(maintenanceForm.getDocTypeName())) { throw new IllegalArgumentException("Document type name or bo class not given!"); } String documentTypeName = maintenanceForm.getDocTypeName(); // get document type if not passed if (StringUtils.isEmpty(documentTypeName)) { documentTypeName = maintenanceDocumentDictionaryService .getDocumentTypeName(Class.forName(maintenanceForm.getBusinessObjectClassName())); maintenanceForm.setDocTypeName(documentTypeName); } if (StringUtils.isEmpty(documentTypeName)) { throw new RuntimeException( "documentTypeName is empty; does this Business Object have a maintenance document definition? " + maintenanceForm.getBusinessObjectClassName()); } // check doc type allows new or copy if that action was requested if (KRADConstants.MAINTENANCE_NEW_ACTION.equals(maintenanceAction) || KRADConstants.MAINTENANCE_COPY_ACTION.equals(maintenanceAction)) { Class boClass = maintenanceDocumentDictionaryService.getDataObjectClass(documentTypeName); boolean allowsNewOrCopy = getBusinessObjectAuthorizationService().canCreate(boClass, GlobalVariables.getUserSession().getPerson(), documentTypeName); if (!allowsNewOrCopy) { LOG.error("Document type " + documentTypeName + " does not allow new or copy actions."); throw new DocumentTypeAuthorizationException( GlobalVariables.getUserSession().getPerson().getPrincipalId(), "newOrCopy", documentTypeName); } } // get new document from service document = (MaintenanceDocument) getDocumentService().getNewDocument(maintenanceForm.getDocTypeName()); maintenanceForm.setDocument(document); } else { document = (MaintenanceDocument) maintenanceForm.getDocument(); } // retrieve business object from request parameters if (!(KRADConstants.MAINTENANCE_NEW_ACTION.equals(maintenanceAction)) && !(KRADConstants.MAINTENANCE_NEWWITHEXISTING_ACTION.equals(maintenanceAction))) { Map requestParameters = buildKeyMapFromRequest(document.getNewMaintainableObject(), request); PersistableBusinessObject oldBusinessObject = null; try { oldBusinessObject = (PersistableBusinessObject) getLookupService().findObjectBySearch( Class.forName(maintenanceForm.getBusinessObjectClassName()), requestParameters); } catch (ClassNotPersistenceCapableException ex) { if (!document.getOldMaintainableObject().isExternalBusinessObject()) { throw new RuntimeException("BO Class: " + maintenanceForm.getBusinessObjectClassName() + " is not persistable and is not externalizable - configuration error"); } // otherwise, let fall through } if (oldBusinessObject == null && !document.getOldMaintainableObject().isExternalBusinessObject()) { throw new RuntimeException( "Cannot retrieve old record for maintenance document, incorrect parameters passed on maint url: " + requestParameters); } if (document.getOldMaintainableObject().isExternalBusinessObject()) { if (oldBusinessObject == null) { try { oldBusinessObject = (PersistableBusinessObject) document.getOldMaintainableObject() .getBoClass().newInstance(); } catch (Exception ex) { throw new RuntimeException( "External BO maintainable was null and unable to instantiate for old maintainable object.", ex); } } populateBOWithCopyKeyValues(request, oldBusinessObject, document.getOldMaintainableObject()); document.getOldMaintainableObject().prepareBusinessObject(oldBusinessObject); oldBusinessObject = document.getOldMaintainableObject().getBusinessObject(); } PersistableBusinessObject newBusinessObject = (PersistableBusinessObject) SerializationUtils .deepCopy(oldBusinessObject); // set business object instance for editing Class<? extends PersistableBusinessObject> businessObjectClass = ClassLoaderUtils .getClass(maintenanceForm.getBusinessObjectClassName(), PersistableBusinessObject.class); document.getOldMaintainableObject().setBusinessObject(oldBusinessObject); document.getOldMaintainableObject().setBoClass(businessObjectClass); document.getNewMaintainableObject().setBusinessObject(newBusinessObject); document.getNewMaintainableObject().setBoClass(businessObjectClass); // on a COPY, clear any fields that this user isnt authorized for, and also // clear the primary key fields and the version number and objectId if (KRADConstants.MAINTENANCE_COPY_ACTION.equals(maintenanceAction)) { if (!document.isFieldsClearedOnCopy()) { //for issue KULRice 3072 Class boClass = maintenanceDocumentDictionaryService .getDataObjectClass(maintenanceForm.getDocTypeName()); if (!maintenanceDocumentDictionaryService.getPreserveLockingKeysOnCopy(boClass)) { clearPrimaryKeyFields(document); } clearUnauthorizedNewFields(document); Maintainable maintainable = document.getNewMaintainableObject(); maintainable.processAfterCopy(document, request.getParameterMap()); // mark so that this clearing doesnt happen again document.setFieldsClearedOnCopy(true); // mark so that blank required fields will be populated with default values maintainable.setGenerateBlankRequiredValues(maintenanceForm.getDocTypeName()); } } else if (KRADConstants.MAINTENANCE_EDIT_ACTION.equals(maintenanceAction)) { boolean allowsEdit = getBusinessObjectAuthorizationService().canMaintain(oldBusinessObject, GlobalVariables.getUserSession().getPerson(), document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()); if (!allowsEdit) { LOG.error("Document type " + document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName() + " does not allow edit actions."); throw new DocumentTypeAuthorizationException( GlobalVariables.getUserSession().getPerson().getPrincipalId(), "edit", document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()); } document.getNewMaintainableObject().processAfterEdit(document, request.getParameterMap()); } //3070 else if (KRADConstants.MAINTENANCE_DELETE_ACTION.equals(maintenanceAction)) { boolean allowsDelete = getBusinessObjectAuthorizationService().canMaintain(oldBusinessObject, GlobalVariables.getUserSession().getPerson(), document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()); if (!allowsDelete) { LOG.error("Document type " + document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName() + " does not allow delete actions."); throw new DocumentTypeAuthorizationException( GlobalVariables.getUserSession().getPerson().getPrincipalId(), "delete", document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()); } //document.getNewMaintainableObject().processAfterEdit( document, request.getParameterMap() ); } } // if new with existing we need to populate we need to populate with passed in parameters if (KRADConstants.MAINTENANCE_NEWWITHEXISTING_ACTION.equals(maintenanceAction)) { // TODO: this code should be abstracted out into a helper // also is it a problem that we're not calling setGenerateDefaultValues? it blanked out the below values when I did // maybe we need a new generateDefaultValues that doesn't overwrite? PersistableBusinessObject newBO = document.getNewMaintainableObject().getBusinessObject(); Map<String, String> parameters = buildKeyMapFromRequest(document.getNewMaintainableObject(), request); copyParametersToBO(parameters, newBO); newBO.refresh(); document.getNewMaintainableObject().setupNewFromExisting(document, request.getParameterMap()); } // for new maintainble need to pick up default values if (KRADConstants.MAINTENANCE_NEW_ACTION.equals(maintenanceAction)) { document.getNewMaintainableObject().setGenerateDefaultValues(maintenanceForm.getDocTypeName()); document.getNewMaintainableObject().processAfterNew(document, request.getParameterMap()); // If a maintenance lock exists, warn the user. MaintenanceUtils.checkForLockingDocument(document.getNewMaintainableObject(), false); } // set maintenance action state document.getNewMaintainableObject().setMaintenanceAction(maintenanceAction); maintenanceForm.setMaintenanceAction(maintenanceAction); // attach any extra JS from the data dictionary MaintenanceDocumentEntry entry = maintenanceDocumentDictionaryService.getMaintenanceDocumentEntry( document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()); if (LOG.isDebugEnabled()) { LOG.debug("maintenanceForm.getAdditionalScriptFiles(): " + maintenanceForm.getAdditionalScriptFiles()); } if (maintenanceForm.getAdditionalScriptFiles().isEmpty()) { maintenanceForm.getAdditionalScriptFiles().addAll(entry.getWebScriptFiles()); } // Retrieve notes topic display flag from data dictionary and add to document document.setDisplayTopicFieldInNotes(entry.getDisplayTopicFieldInNotes()); return mapping.findForward(RiceConstants.MAPPING_BASIC); } protected void populateBOWithCopyKeyValues(HttpServletRequest request, PersistableBusinessObject oldBusinessObject, Maintainable oldMaintainableObject) throws Exception { List keyFieldNamesToCopy = new ArrayList(); Map<String, String> parametersToCopy; if (!StringUtils.isBlank(request.getParameter(KRADConstants.COPY_KEYS))) { String[] copyKeys = request.getParameter(KRADConstants.COPY_KEYS) .split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR); for (String copyKey : copyKeys) { keyFieldNamesToCopy.add(copyKey); } } parametersToCopy = getRequestParameters(keyFieldNamesToCopy, oldMaintainableObject, request); if (parametersToCopy != null && parametersToCopy.size() > 0) { copyParametersToBO(parametersToCopy, oldBusinessObject); } } protected void copyParametersToBO(Map<String, String> parameters, PersistableBusinessObject newBO) throws Exception { for (String parmName : parameters.keySet()) { String propertyValue = parameters.get(parmName); if (StringUtils.isNotBlank(propertyValue)) { String propertyName = parmName; // set value of property in bo if (PropertyUtils.isWriteable(newBO, propertyName)) { Class type = ObjectUtils.easyGetPropertyType(newBO, propertyName); if (type != null && Formatter.getFormatter(type) != null) { Formatter formatter = Formatter.getFormatter(type); Object obj = formatter.convertFromPresentationFormat(propertyValue); ObjectUtils.setObjectProperty(newBO, propertyName, obj.getClass(), obj); } else { ObjectUtils.setObjectProperty(newBO, propertyName, String.class, propertyValue); } } } } } /** * Downloads the attachment to the user's browser * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward downloadAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form; MaintenanceDocumentBase document = (MaintenanceDocumentBase) documentForm.getDocument(); int line = getSelectedLine(request); if (line < 0) { DocumentAttachment documentAttachment = document.getAttachment(); if (documentAttachment != null && documentAttachment.getAttachmentContent() != null) { streamToResponse(documentAttachment.getAttachmentContent(), documentAttachment.getFileName(), documentAttachment.getContentType(), response); return null; } PersistableAttachment attachment = (PersistableAttachment) document.getNewMaintainableObject() .getBusinessObject(); String attachmentPropNm = document.getAttachmentPropertyName(); FormFile attachmentFromBusinessObject = null; byte[] attachmentContent; String fileName = attachment.getFileName(); String contentType = attachment.getContentType(); if (StringUtils.isNotBlank(attachmentPropNm)) { String attachmentPropNmSetter = "get" + attachmentPropNm.substring(0, 1).toUpperCase() + attachmentPropNm.substring(1, attachmentPropNm.length()); attachmentFromBusinessObject = (FormFile) (attachment.getClass() .getDeclaredMethod(attachmentPropNmSetter).invoke(attachment)); } if (attachmentFromBusinessObject != null && attachmentFromBusinessObject.getInputStream() != null) { attachmentContent = attachmentFromBusinessObject.getFileData(); fileName = attachmentFromBusinessObject.getFileName(); contentType = attachmentFromBusinessObject.getContentType(); } else { attachmentContent = attachment.getAttachmentContent(); } if (StringUtils.isNotBlank(fileName) && contentType != null && attachmentContent != null) { streamToResponse(attachmentContent, fileName, contentType, response); } } else { // attachment is part of a collection PersistableAttachmentList<PersistableAttachment> attachmentsBo = (PersistableAttachmentList<PersistableAttachment>) document .getNewMaintainableObject().getBusinessObject(); if (CollectionUtils.isEmpty(attachmentsBo.getAttachments())) { document.populateAttachmentListForBO(); } List<? extends PersistableAttachment> attachments = attachmentsBo.getAttachments(); if (CollectionUtils.isNotEmpty(attachments) && attachments.size() > line) { PersistableAttachment attachment = attachmentsBo.getAttachments().get(line); //it is possible that document hasn't been saved (attachment just added) and the attachment content is still in the FormFile //need to grab it if that is the case. byte[] attachmentContent; // = attachment.getAttachmentContent(); String fileName = attachment.getFileName(); String contentType = attachment.getContentType(); String attachmentPropNm = document.getAttachmentListPropertyName(); FormFile attachmentFromBusinessObject = null; if (StringUtils.isNotBlank(attachmentPropNm)) { String attachmentPropNmSetter = "get" + attachmentPropNm.substring(0, 1).toUpperCase() + attachmentPropNm.substring(1, attachmentPropNm.length()); attachmentFromBusinessObject = (FormFile) (attachment.getClass() .getDeclaredMethod(attachmentPropNmSetter).invoke(attachment)); } //Use form file data if it exists //if (attachmentContent == null) { if (attachmentFromBusinessObject != null && attachmentFromBusinessObject.getInputStream() != null) { attachmentContent = attachmentFromBusinessObject.getFileData(); fileName = attachmentFromBusinessObject.getFileName(); contentType = attachmentFromBusinessObject.getContentType(); } else { attachmentContent = attachment.getAttachmentContent(); } if (attachmentContent != null) { streamToResponse(attachmentContent, fileName, contentType, response); } else { // last ditch effort to find the correct attachment //check to see if attachment is populated on document first, so no copying done unless necessary List<MultiDocumentAttachment> multiDocumentAttachs = document.getAttachments(); if (CollectionUtils.isNotEmpty(multiDocumentAttachs)) { for (MultiDocumentAttachment multiAttach : multiDocumentAttachs) { if (multiAttach.getFileName().equals(fileName) && multiAttach.getContentType().equals(contentType)) { streamToResponse(multiAttach.getAttachmentContent(), multiAttach.getFileName(), multiAttach.getContentType(), response); break; } } } } } } return null; } /** * * This method used to replace the attachment * @param mapping * @param form * @param request * @param response * @return * @throws Exception */ public ActionForward replaceAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form; MaintenanceDocumentBase document = (MaintenanceDocumentBase) documentForm.getDocument(); int lineNum = getSelectedLine(request); if (lineNum < 0) { document.refreshReferenceObject("attachment"); documentForm.setAttachmentFile(null); document.setFileAttachment(null); getBusinessObjectService().delete(document.getAttachment()); document.setAttachment(null); PersistableAttachment attachment = (PersistableAttachment) document.getNewMaintainableObject() .getBusinessObject(); attachment.setAttachmentContent(null); attachment.setContentType(null); attachment.setFileName(null); //pBo.setAttachmentFile(null); String attachmentPropNm = document.getAttachmentPropertyName(); String attachmentPropNmSetter = "set" + attachmentPropNm.substring(0, 1).toUpperCase() + attachmentPropNm.substring(1, attachmentPropNm.length()); Class propNameSetterSig = null; try { Method[] methods = attachment.getClass().getMethods(); for (Method method : methods) { if (method.getName().equals(attachmentPropNmSetter)) { propNameSetterSig = method.getParameterTypes()[0]; attachment.getClass().getDeclaredMethod(attachmentPropNmSetter, propNameSetterSig) .invoke(attachment, (Object) null); break; } } } catch (Exception e) { LOG.error("Not able to get the attachment " + e.getMessage()); throw new RuntimeException("Not able to get the attachment " + e.getMessage()); } } else { document.refreshReferenceObject("attachments"); getBusinessObjectService().delete(document.getAttachment()); PersistableAttachmentList<PersistableAttachment> attachmentListBo = (PersistableAttachmentList<PersistableAttachment>) document .getNewMaintainableObject().getBusinessObject(); PersistableAttachment attachment = (PersistableAttachment) attachmentListBo.getAttachments() .get(lineNum); attachment.setAttachmentContent(null); attachment.setContentType(null); attachment.setFileName(null); String attachmentPropNm = document.getAttachmentListPropertyName(); String attachmentPropNmSetter = "set" + attachmentPropNm.substring(0, 1).toUpperCase() + attachmentPropNm.substring(1, attachmentPropNm.length()); Class propNameSetterSig = null; try { Method[] methods = attachment.getClass().getMethods(); for (Method method : methods) { if (method.getName().equals(attachmentPropNmSetter)) { propNameSetterSig = method.getParameterTypes()[0]; attachment.getClass().getDeclaredMethod(attachmentPropNmSetter, propNameSetterSig) .invoke(attachment, (Object) null); break; } } } catch (Exception e) { LOG.error("Not able to get the attachment " + e.getMessage()); throw new RuntimeException("Not able to get the attachment " + e.getMessage()); } } return mapping.findForward(RiceConstants.MAPPING_BASIC); } /** * route the document using the document service * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ @Override public ActionForward route(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form; MaintenanceDocumentBase document = (MaintenanceDocumentBase) documentForm.getDocument(); ActionForward forward = super.route(mapping, form, request, response); PersistableBusinessObject businessObject = document.getNewMaintainableObject().getBusinessObject(); if (businessObject instanceof PersistableAttachment) { document.populateAttachmentForBO(); String fileName = ((PersistableAttachment) businessObject).getFileName(); if (StringUtils.isEmpty(fileName)) { PersistableAttachment existingBO = (PersistableAttachment) getBusinessObjectService() .retrieve(document.getNewMaintainableObject().getBusinessObject()); if (existingBO == null) { if (document.getAttachment() != null) { fileName = document.getAttachment().getFileName(); } else { fileName = ""; } } else { fileName = (existingBO != null ? existingBO.getFileName() : ""); } request.setAttribute("fileName", fileName); } } return forward; } /** * Handles creating and loading of documents. */ @Override public ActionForward docHandler(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { ActionForward af = super.docHandler(mapping, form, request, response); if (af.getName().equals(KRADConstants.KRAD_INITIATED_DOCUMENT_VIEW_NAME)) { return af; } KualiMaintenanceForm kualiMaintenanceForm = (KualiMaintenanceForm) form; if (KewApiConstants.ACTIONLIST_COMMAND.equals(kualiMaintenanceForm.getCommand()) || KewApiConstants.DOCSEARCH_COMMAND.equals(kualiMaintenanceForm.getCommand()) || KewApiConstants.SUPERUSER_COMMAND.equals(kualiMaintenanceForm.getCommand()) || KewApiConstants.HELPDESK_ACTIONLIST_COMMAND.equals(kualiMaintenanceForm.getCommand()) && kualiMaintenanceForm.getDocId() != null) { if (kualiMaintenanceForm.getDocument() instanceof MaintenanceDocument) { kualiMaintenanceForm.setReadOnly(true); kualiMaintenanceForm.setMaintenanceAction(((MaintenanceDocument) kualiMaintenanceForm.getDocument()) .getNewMaintainableObject().getMaintenanceAction()); //Retrieving the FileName from BO table Maintainable tmpMaintainable = ((MaintenanceDocument) kualiMaintenanceForm.getDocument()) .getNewMaintainableObject(); if (tmpMaintainable.getBusinessObject() instanceof PersistableAttachment) { PersistableAttachment bo = (PersistableAttachment) getBusinessObjectService() .retrieve(tmpMaintainable.getBusinessObject()); if (bo != null) { request.setAttribute("fileName", bo.getFileName()); } } } else { LOG.error("Illegal State: document is not a maintenance document"); throw new IllegalArgumentException("Document is not a maintenance document"); } } else if (KewApiConstants.INITIATE_COMMAND.equals(kualiMaintenanceForm.getCommand())) { kualiMaintenanceForm.setReadOnly(false); return setupMaintenance(mapping, form, request, response, KRADConstants.MAINTENANCE_NEW_ACTION); } else { LOG.error("We should never have gotten to here"); throw new IllegalArgumentException("docHandler called with invalid parameters"); } return mapping.findForward(RiceConstants.MAPPING_BASIC); } /** * Called on return from a lookup. */ @Override public ActionForward refresh(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) form; WebUtils.reuseErrorMapFromPreviousRequest(maintenanceForm); maintenanceForm.setDerivedValuesOnForm(request); refreshAdHocRoutingWorkgroupLookups(request, maintenanceForm); MaintenanceDocument document = (MaintenanceDocument) maintenanceForm.getDocument(); // call refresh on new maintainable Map<String, String> requestParams = new HashMap<String, String>(); for (Enumeration i = request.getParameterNames(); i.hasMoreElements();) { String requestKey = (String) i.nextElement(); String requestValue = request.getParameter(requestKey); requestParams.put(requestKey, requestValue); } // Add multiple values from Lookup Collection<PersistableBusinessObject> rawValues = null; if (StringUtils.equals(KRADConstants.MULTIPLE_VALUE, maintenanceForm.getRefreshCaller())) { String lookupResultsSequenceNumber = maintenanceForm.getLookupResultsSequenceNumber(); if (StringUtils.isNotBlank(lookupResultsSequenceNumber)) { // actually returning from a multiple value lookup String lookupResultsBOClassName = maintenanceForm.getLookupResultsBOClassName(); Class lookupResultsBOClass = Class.forName(lookupResultsBOClassName); rawValues = getLookupResultsService().retrieveSelectedResultBOs(lookupResultsSequenceNumber, lookupResultsBOClass, GlobalVariables.getUserSession().getPerson().getPrincipalId()); } } if (rawValues != null) { // KULCOA-1073 - caused by this block running unnecessarily? // we need to run the business rules on all the newly added items to the collection // KULCOA-1000, KULCOA-1004 removed business rule validation on multiple value return // (this was running before the objects were added anyway) // getKualiRuleService().applyRules(new SaveDocumentEvent(document)); String collectionName = maintenanceForm.getLookedUpCollectionName(); //TODO: Cathy remember to delete this block of comments after I've tested. // PersistableBusinessObject bo = document.getNewMaintainableObject().getBusinessObject(); // Collection maintCollection = this.extractCollection(bo, collectionName); // String docTypeName = ((MaintenanceDocument) maintenanceForm.getDocument()).getDocumentHeader().getWorkflowDocument().getDocumentType(); // Class collectionClass = extractCollectionClass(docTypeName, collectionName); // // List<MaintainableSectionDefinition> sections = maintenanceDocumentDictionaryService.getMaintainableSections(docTypeName); // Map<String, String> template = MaintenanceUtils.generateMultipleValueLookupBOTemplate(sections, collectionName); // for (PersistableBusinessObject nextBo : rawValues) { // PersistableBusinessObject templatedBo = (PersistableBusinessObject) ObjectUtils.createHybridBusinessObject(collectionClass, nextBo, template); // templatedBo.setNewCollectionRecord(true); // maintCollection.add(templatedBo); // } document.getNewMaintainableObject().addMultipleValueLookupResults(document, collectionName, rawValues, false, document.getNewMaintainableObject().getBusinessObject()); if (LOG.isInfoEnabled()) { LOG.info("********************doing editing 3 in refersh()***********************."); } boolean isEdit = KRADConstants.MAINTENANCE_EDIT_ACTION.equals(maintenanceForm.getMaintenanceAction()); boolean isCopy = KRADConstants.MAINTENANCE_COPY_ACTION.equals(maintenanceForm.getMaintenanceAction()); if (isEdit || isCopy) { document.getOldMaintainableObject().addMultipleValueLookupResults(document, collectionName, rawValues, true, document.getOldMaintainableObject().getBusinessObject()); document.getOldMaintainableObject().refresh(maintenanceForm.getRefreshCaller(), requestParams, document); } } document.getNewMaintainableObject().refresh(maintenanceForm.getRefreshCaller(), requestParams, document); //pass out customAction from methodToCall parameter. Call processAfterPost String fullParameter = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE); if (StringUtils.contains(fullParameter, KRADConstants.CUSTOM_ACTION)) { String customAction = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL); String[] actionValue = new String[1]; actionValue[0] = StringUtils.substringAfter(customAction, "."); Map<String, String[]> paramMap = new HashMap<String, String[]>(request.getParameterMap()); paramMap.put(KRADConstants.CUSTOM_ACTION, actionValue); doProcessingAfterPost((KualiMaintenanceForm) form, paramMap); } return mapping.findForward(RiceConstants.MAPPING_BASIC); } /** * Gets keys for the maintainable business object from the persistence metadata explorer. Checks for existence of key property * names as request parameters, if found adds them to the returned hash map. */ protected Map buildKeyMapFromRequest(Maintainable maintainable, HttpServletRequest request) { List keyFieldNames = null; // are override keys listed in the request? If so, then those need to be our keys, // not the primary keye fields for the BO if (!StringUtils.isBlank(request.getParameter(KRADConstants.OVERRIDE_KEYS))) { String[] overrideKeys = request.getParameter(KRADConstants.OVERRIDE_KEYS) .split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR); keyFieldNames = new ArrayList(); for (String overrideKey : overrideKeys) { keyFieldNames.add(overrideKey); } } else { keyFieldNames = KRADServiceLocatorWeb.getLegacyDataAdapter() .listPrimaryKeyFieldNames(maintainable.getBusinessObject().getClass()); } return getRequestParameters(keyFieldNames, maintainable, request); } protected Map<String, String> getRequestParameters(List keyFieldNames, Maintainable maintainable, HttpServletRequest request) { Map<String, String> requestParameters = new HashMap<String, String>(); for (Iterator iter = keyFieldNames.iterator(); iter.hasNext();) { String keyPropertyName = (String) iter.next(); if (request.getParameter(keyPropertyName) != null) { String keyValue = request.getParameter(keyPropertyName); // Check if this element was encrypted, if it was decrypt it if (getBusinessObjectAuthorizationService().attributeValueNeedsToBeEncryptedOnFormsAndLinks( maintainable.getBoClass(), keyPropertyName)) { try { keyValue = StringUtils.removeEnd(keyValue, EncryptionService.ENCRYPTION_POST_PREFIX); if (CoreApiServiceLocator.getEncryptionService().isEnabled()) { keyValue = encryptionService.decrypt(keyValue); } } catch (GeneralSecurityException e) { throw new RuntimeException(e); } } requestParameters.put(keyPropertyName, keyValue); } } return requestParameters; } /** * Convert a Request into a Map<String,String>. Technically, Request parameters do not neatly translate into a Map of Strings, * because a given parameter may legally appear more than once (so a Map of String[] would be more accurate.) This method should * be safe for business objects, but may not be reliable for more general uses. */ String extractCollectionName(HttpServletRequest request, String methodToCall) { // collection name and underlying object type from request parameter String parameterName = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE); String collectionName = null; if (StringUtils.isNotBlank(parameterName)) { collectionName = StringUtils.substringBetween(parameterName, methodToCall + ".", ".("); } return collectionName; } Collection extractCollection(Object bo, String collectionName) { // retrieve the collection from the business object Collection maintCollection = (Collection) ObjectUtils.getPropertyValue(bo, collectionName); return maintCollection; } Class extractCollectionClass(String docTypeName, String collectionName) { return maintenanceDocumentDictionaryService.getCollectionBusinessObjectClass(docTypeName, collectionName); } /** * Adds a line to a collection being maintained in a many section. */ public ActionForward addLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) form; MaintenanceDocument document = (MaintenanceDocument) maintenanceForm.getDocument(); Maintainable oldMaintainable = document.getOldMaintainableObject(); Maintainable newMaintainable = document.getNewMaintainableObject(); String collectionName = extractCollectionName(request, KRADConstants.ADD_LINE_METHOD); if (collectionName == null) { LOG.error("Unable to get find collection name and class in request."); throw new RuntimeException("Unable to get find collection name and class in request."); } // if dealing with sub collection it will have a "[" if ((StringUtils.lastIndexOf(collectionName, "]") + 1) == collectionName.length()) { collectionName = StringUtils.substringBeforeLast(collectionName, "["); } Object bo = newMaintainable.getBusinessObject(); Collection maintCollection = extractCollection(bo, collectionName); Class collectionClass = extractCollectionClass(((MaintenanceDocument) maintenanceForm.getDocument()) .getDocumentHeader().getWorkflowDocument().getDocumentTypeName(), collectionName); // TODO: sort of collection, new instance should be first // get the BO from the new collection line holder PersistableBusinessObject addBO = newMaintainable.getNewCollectionLine(collectionName); if (LOG.isDebugEnabled()) { LOG.debug("obtained addBO from newCollectionLine: " + addBO); } // link up the user fields, if any getBusinessObjectService().linkUserFields(addBO); //KULRICE-4264 - a hook to change the state of the business object, which is the "new line" of a collection, before it is validated newMaintainable.processBeforeAddLine(collectionName, collectionClass, addBO); // apply rules to the addBO boolean rulePassed = false; if (LOG.isDebugEnabled()) { LOG.debug("about to call AddLineEvent applyRules: document=" + document + "\ncollectionName=" + collectionName + "\nBO=" + addBO); } rulePassed = getKualiRuleService().applyRules(new KualiAddLineEvent(document, collectionName, addBO)); // if the rule evaluation passed, let's add it if (rulePassed) { if (LOG.isInfoEnabled()) { LOG.info("********************doing editing 4 in addline()***********************."); } // if edit or copy action, just add empty instance to old maintainable boolean isEdit = KRADConstants.MAINTENANCE_EDIT_ACTION.equals(maintenanceForm.getMaintenanceAction()); boolean isCopy = KRADConstants.MAINTENANCE_COPY_ACTION.equals(maintenanceForm.getMaintenanceAction()); if (isEdit || isCopy) { Object oldBo = oldMaintainable.getBusinessObject(); Collection oldMaintCollection = (Collection) ObjectUtils.getPropertyValue(oldBo, collectionName); if (oldMaintCollection == null) { oldMaintCollection = new ArrayList(); } if (PersistableBusinessObject.class.isAssignableFrom(collectionClass)) { PersistableBusinessObject placeholder = (PersistableBusinessObject) collectionClass .newInstance(); // KULRNE-4538: must set it as a new collection record, because the maintainable will set the BO that gets added // to the new maintainable as a new collection record // if not set, then the subcollections of the newly added object will appear as read only // see FieldUtils.getContainerRows on how the delete button is rendered placeholder.setNewCollectionRecord(true); ((List) oldMaintCollection).add(placeholder); } else { LOG.warn("Should be a instance of PersistableBusinessObject"); ((List) oldMaintCollection).add(collectionClass.newInstance()); } // update collection in maintenance business object ObjectUtils.setObjectProperty(oldBo, collectionName, List.class, oldMaintCollection); } newMaintainable.addNewLineToCollection(collectionName); int subCollectionIndex = 0; for (Object aSubCollection : maintCollection) { subCollectionIndex += getSubCollectionIndex(aSubCollection, maintenanceForm.getDocTypeName()); } //TODO: Should we keep this logic and continue using currentTabIndex as the key in the tabStates HashMap ? // // String parameter = (String) request.getAttribute(Constants.METHOD_TO_CALL_ATTRIBUTE); // String indexStr = StringUtils.substringBetween(parameter, Constants.METHOD_TO_CALL_PARM13_LEFT_DEL, Constants.METHOD_TO_CALL_PARM13_RIGHT_DEL); // // + 1 is for the fact that the first element of a collection is on the next tab // int index = Integer.parseInt(indexStr) + subCollectionIndex + 1; // Map<String, String> tabStates = maintenanceForm.getTabStates(); // Map<String, String> copyOfTabStates = new HashMap<String, String>(); // // int incrementor = 0; // for (String tabState : tabStates.keySet()) { // String originalValue = maintenanceForm.getTabState(Integer.toString(incrementor)); // copyOfTabStates.put(Integer.toString(incrementor), originalValue); // incrementor++; // } // // int i = index; // if (tabStates.containsKey(Integer.toString(i-1))) { // tabStates.remove(Integer.toString(i-1)); // } // while (i < copyOfTabStates.size() + 1) { // String originalValue = copyOfTabStates.get(Integer.toString(i-1)); // if (tabStates.containsKey(Integer.toString(i))) { // tabStates.remove(Integer.toString(i)); // } // tabStates.put(Integer.toString(i), originalValue); // i++; // } // End of whether we should continue to keep this logic and use currentTabIndex as the key } doProcessingAfterPost((KualiMaintenanceForm) form, request); return mapping.findForward(RiceConstants.MAPPING_BASIC); } protected int getSubCollectionIndex(Object object, String documentTypeName) { int index = 1; MaintainableCollectionDefinition theCollectionDefinition = null; for (MaintainableCollectionDefinition maintainableCollectionDefinition : maintenanceDocumentDictionaryService .getMaintainableCollections(documentTypeName)) { if (maintainableCollectionDefinition.getBusinessObjectClass().equals(object.getClass())) { // we've found the collection we were looking for, so let's find all of its subcollections theCollectionDefinition = maintainableCollectionDefinition; break; } } if (theCollectionDefinition != null) { for (MaintainableCollectionDefinition subCollDef : theCollectionDefinition .getMaintainableCollections()) { String name = subCollDef.getName(); String capitalFirst = name.substring(0, 1).toUpperCase(); String methodName = "get" + capitalFirst + name.substring(1); List subCollectionList = new ArrayList(); try { subCollectionList = (List) object.getClass().getMethod(methodName).invoke(object); } catch (InvocationTargetException ite) { // this shouldn't happen } catch (IllegalAccessException iae) { // this shouldn't happen } catch (NoSuchMethodException nme) { // this shouldn't happen } index += subCollectionList.size(); } } return index; } /** * Deletes a collection line that is pending by this document. The collection name and the index to delete is embedded into the * delete button name. These parameters are extracted, the collection pulled out of the parent business object, and finally the * collection record at the specified index is removed for the new maintainable, and the old if we are dealing with an edit. */ public ActionForward deleteLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) form; MaintenanceDocument document = (MaintenanceDocument) maintenanceForm.getDocument(); Maintainable oldMaintainable = document.getOldMaintainableObject(); Maintainable newMaintainable = document.getNewMaintainableObject(); String collectionName = extractCollectionName(request, KRADConstants.DELETE_LINE_METHOD); if (collectionName == null) { LOG.error("Unable to get find collection name in request."); throw new RuntimeException("Unable to get find collection class in request."); } PersistableBusinessObject bo = newMaintainable.getBusinessObject(); Collection maintCollection = extractCollection(bo, collectionName); if (collectionName == null) { LOG.error("Collection is null in parent business object."); throw new RuntimeException("Collection is null in parent business object."); } int deleteRecordIndex = getLineToDelete(request); if (deleteRecordIndex < 0 || deleteRecordIndex > maintCollection.size() - 1) { if (collectionName == null) { LOG.error("Invalid index for deletion of collection record: " + deleteRecordIndex); throw new RuntimeException("Invalid index for deletion of collection record: " + deleteRecordIndex); } } ((List) maintCollection).remove(deleteRecordIndex); // if it's either an edit or a copy, need to remove the collection from the old maintainable as well if (KRADConstants.MAINTENANCE_EDIT_ACTION.equals(maintenanceForm.getMaintenanceAction()) || KRADConstants.MAINTENANCE_COPY_ACTION.equals(maintenanceForm.getMaintenanceAction())) { bo = oldMaintainable.getBusinessObject(); maintCollection = extractCollection(bo, collectionName); if (collectionName == null) { LOG.error("Collection is null in parent business object."); throw new RuntimeException("Collection is null in parent business object."); } ((List) maintCollection).remove(deleteRecordIndex); } // remove the tab state information of the tab that the deleted element originally occupied, so that it will keep tab states // consistent // String parameter = (String) request.getAttribute(Constants.METHOD_TO_CALL_ATTRIBUTE); // String indexStr = StringUtils.substringBetween(parameter, Constants.METHOD_TO_CALL_PARM13_LEFT_DEL, Constants.METHOD_TO_CALL_PARM13_RIGHT_DEL); // int index = Integer.parseInt(indexStr); // maintenanceForm.removeTabState(index); // TODO: Should we keep this logic and continue using currentTabIndex as the key in the tabStates HashMap ? // // String parameter = (String) request.getAttribute(Constants.METHOD_TO_CALL_ATTRIBUTE); // String indexStr = StringUtils.substringBetween(parameter, Constants.METHOD_TO_CALL_PARM13_LEFT_DEL, Constants.METHOD_TO_CALL_PARM13_RIGHT_DEL); // // + 1 is for the fact that the first element of a collection is on the next tab // int index = Integer.parseInt(indexStr) + 1; // Map<String, String> tabStates = maintenanceForm.getTabStates(); // Map<String, String> copyOfTabStates = new HashMap<String, String>(); // // int incrementor = 0; // for (String tabState : tabStates.keySet()) { // String originalValue = maintenanceForm.getTabState(Integer.toString(incrementor)); // copyOfTabStates.put(Integer.toString(incrementor), originalValue); // incrementor++; // } // // int i = index; // // while (i < copyOfTabStates.size() ) { // String originalValue = copyOfTabStates.get(Integer.toString(i)); // if (tabStates.containsKey(Integer.toString(i-1))) { // tabStates.remove(Integer.toString(i-1)); // } // tabStates.put(Integer.toString(i-1), originalValue); // i++; // } // // //End of whether we should continue to keep this logic and use currentTabIndex as the key doProcessingAfterPost((KualiMaintenanceForm) form, request); return mapping.findForward(RiceConstants.MAPPING_BASIC); } /** * Turns on (or off) the inactive record display for a maintenance collection. */ public ActionForward toggleInactiveRecordDisplay(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) form; MaintenanceDocument document = (MaintenanceDocument) maintenanceForm.getDocument(); Maintainable oldMaintainable = document.getOldMaintainableObject(); Maintainable newMaintainable = document.getNewMaintainableObject(); String collectionName = extractCollectionName(request, KRADConstants.TOGGLE_INACTIVE_METHOD); if (collectionName == null) { LOG.error("Unable to get find collection name in request."); throw new RuntimeException("Unable to get find collection class in request."); } String parameterName = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE); boolean showInactive = Boolean.parseBoolean( StringUtils.substringBetween(parameterName, KRADConstants.METHOD_TO_CALL_BOPARM_LEFT_DEL, ".")); oldMaintainable.setShowInactiveRecords(collectionName, showInactive); newMaintainable.setShowInactiveRecords(collectionName, showInactive); return mapping.findForward(RiceConstants.MAPPING_BASIC); } /** * This method clears the value of the primary key fields on a Business Object. * * @param document - document to clear the pk fields on */ protected void clearPrimaryKeyFields(MaintenanceDocument document) { // get business object being maintained and its keys PersistableBusinessObject bo = document.getNewMaintainableObject().getBusinessObject(); List<String> keyFieldNames = KRADServiceLocatorWeb.getLegacyDataAdapter() .listPrimaryKeyFieldNames(bo.getClass()); for (String keyFieldName : keyFieldNames) { try { ObjectUtils.setObjectProperty(bo, keyFieldName, null); } catch (Exception e) { LOG.error("Unable to clear primary key field: " + e.getMessage()); throw new RuntimeException("Unable to clear primary key field: " + e.getMessage()); } } bo.setObjectId(null); bo.setVersionNumber(new Long(1)); } /** * This method is used as part of the Copy functionality, to clear any field values that the user making the copy does not have * permissions to modify. This will prevent authorization errors on a copy. * * @param document - document to be adjusted */ protected void clearUnauthorizedNewFields(MaintenanceDocument document) { // get a reference to the current user Person user = GlobalVariables.getUserSession().getPerson(); // get a new instance of MaintenanceDocumentAuthorizations for this context MaintenanceDocumentRestrictions maintenanceDocumentRestrictions = getBusinessObjectAuthorizationService() .getMaintenanceDocumentRestrictions(document, user); document.getNewMaintainableObject().clearBusinessObjectOfRestrictedValues(maintenanceDocumentRestrictions); } /** * This method does all special processing on a document that should happen on each HTTP post (ie, save, route, approve, etc). * * @param form */ @SuppressWarnings("unchecked") protected void doProcessingAfterPost(KualiForm form, HttpServletRequest request) { MaintenanceDocument document = (MaintenanceDocument) ((KualiMaintenanceForm) form).getDocument(); Maintainable maintainable = document.getNewMaintainableObject(); Object bo = maintainable.getBusinessObject(); getBusinessObjectService().linkUserFields(bo); maintainable.processAfterPost(document, request.getParameterMap()); } protected void doProcessingAfterPost(KualiForm form, Map<String, String[]> parameters) { MaintenanceDocument document = (MaintenanceDocument) ((KualiMaintenanceForm) form).getDocument(); Maintainable maintainable = document.getNewMaintainableObject(); Object bo = maintainable.getBusinessObject(); getBusinessObjectService().linkUserFields(bo); maintainable.processAfterPost(document, parameters); } protected void populateAuthorizationFields(KualiDocumentFormBase formBase) { super.populateAuthorizationFields(formBase); KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) formBase; MaintenanceDocument maintenanceDocument = (MaintenanceDocument) maintenanceForm.getDocument(); MaintenanceDocumentAuthorizer maintenanceDocumentAuthorizer = (MaintenanceDocumentAuthorizer) getDocumentHelperService() .getDocumentAuthorizer(maintenanceDocument); Person user = GlobalVariables.getUserSession().getPerson(); maintenanceForm .setReadOnly(!formBase.getDocumentActions().containsKey(KRADConstants.KUALI_ACTION_CAN_EDIT)); MaintenanceDocumentRestrictions maintenanceDocumentAuthorizations = getBusinessObjectAuthorizationService() .getMaintenanceDocumentRestrictions(maintenanceDocument, user); maintenanceForm.setAuthorizations(maintenanceDocumentAuthorizations); } public LookupService getLookupService() { if (lookupService == null) { lookupService = KRADServiceLocatorWeb.getLookupService(); } return this.lookupService; } public LookupResultsService getLookupResultsService() { if (lookupResultsService == null) { lookupResultsService = KNSServiceLocator.getLookupResultsService(); } return this.lookupResultsService; } }