Java tutorial
/* * Copyright 2007 The Kuali Foundation * * Licensed under the Educational Community License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.opensource.org/licenses/ecl2.php * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.kuali.ole.sys.web.struts; import static org.kuali.ole.sys.OLEKeyConstants.ERROR_DOCUMENT_ACCOUNTING_LINE_SALES_TAX_INVALID_ACCOUNT; import static org.kuali.ole.sys.OLEKeyConstants.ERROR_DOCUMENT_ACCOUNTING_LINE_SALES_TAX_REQUIRED; import static org.kuali.ole.sys.OLEKeyConstants.ERROR_REQUIRED; import java.io.FileNotFoundException; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Properties; import java.util.Set; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.lang.StringUtils; 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.ole.fp.businessobject.SalesTax; import org.kuali.ole.sys.OLEConstants; import org.kuali.ole.sys.OLEKeyConstants; import org.kuali.ole.sys.OLEPropertyConstants; import org.kuali.ole.sys.businessobject.AccountingLine; import org.kuali.ole.sys.businessobject.AccountingLineOverride; import org.kuali.ole.sys.businessobject.AccountingLineParser; import org.kuali.ole.sys.businessobject.FinancialSystemDocumentHeader; import org.kuali.ole.sys.businessobject.GeneralLedgerPendingEntry; import org.kuali.ole.sys.businessobject.SourceAccountingLine; import org.kuali.ole.sys.businessobject.TargetAccountingLine; import org.kuali.ole.sys.context.SpringContext; import org.kuali.ole.sys.document.AccountingDocument; import org.kuali.ole.sys.document.AmountTotaling; import org.kuali.ole.sys.document.validation.event.AddAccountingLineEvent; import org.kuali.ole.sys.document.validation.event.DeleteAccountingLineEvent; import org.kuali.ole.sys.document.validation.impl.AccountingDocumentRuleBaseConstants.APPLICATION_PARAMETER; import org.kuali.ole.sys.document.web.struts.FinancialSystemTransactionalDocumentActionBase; import org.kuali.ole.sys.exception.AccountingLineParserException; import org.kuali.ole.sys.service.impl.OleParameterConstants; import org.kuali.rice.core.api.parameter.ParameterEvaluator; import org.kuali.rice.core.api.parameter.ParameterEvaluatorService; import org.kuali.rice.coreservice.framework.parameter.ParameterService; import org.kuali.rice.kew.api.exception.WorkflowException; import org.kuali.rice.kns.service.DataDictionaryService; import org.kuali.rice.kns.service.DictionaryValidationService; import org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase; import org.kuali.rice.krad.service.BusinessObjectService; import org.kuali.rice.krad.service.KualiRuleService; import org.kuali.rice.krad.service.PersistenceService; import org.kuali.rice.krad.util.GlobalVariables; import org.kuali.rice.krad.util.KRADConstants; import org.kuali.rice.krad.util.ObjectUtils; import org.kuali.rice.krad.util.UrlFactory; /** * This class handles UI actions for all shared methods of financial documents. */ public class KualiAccountingDocumentActionBase extends FinancialSystemTransactionalDocumentActionBase { protected static org.apache.log4j.Logger LOG = org.apache.log4j.Logger .getLogger(KualiAccountingDocumentActionBase.class); /** * Adds check for accountingLine updates, generates and dispatches any events caused by such updates * * @see org.apache.struts.action.Action#execute(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, * javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) */ @Override public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase transForm = (KualiAccountingDocumentFormBase) form; // handle changes to accountingLines if (transForm.hasDocumentId()) { AccountingDocument financialDocument = (AccountingDocument) transForm.getDocument(); processAccountingLines(financialDocument, transForm, OLEConstants.SOURCE); processAccountingLines(financialDocument, transForm, OLEConstants.TARGET); } // This is after a potential handleUpdate(), to display automatically cleared overrides following a route or save. processAccountingLineOverrides(transForm); // proceed as usual ActionForward result = super.execute(mapping, form, request, response); return result; } /** * All document-load operations get routed through here * * @see org.kuali.rice.kns.web.struts.action.KualiDocumentActionBase#loadDocument(org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase) */ @Override protected void loadDocument(KualiDocumentFormBase kualiDocumentFormBase) throws WorkflowException { super.loadDocument(kualiDocumentFormBase); KualiAccountingDocumentFormBase tform = (KualiAccountingDocumentFormBase) kualiDocumentFormBase; // clear out the new accounting line holders tform.setNewSourceLine(null); tform.setNewTargetLine(null); processAccountingLineOverrides(tform); } /** * Needed to override this to keep from losing Sales Tax information * * @see org.kuali.rice.kns.web.struts.action.KualiAction#refresh(org.apache.struts.action.ActionMapping, * org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) */ @Override public ActionForward refresh(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { super.refresh(mapping, form, request, response); refreshSalesTaxInfo(form); return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * Needed to override this to keep from losing Sales Tax information * * @see org.kuali.rice.kns.web.struts.action.KualiAction#toggleTab(org.apache.struts.action.ActionMapping, * org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) */ @Override public ActionForward toggleTab(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { super.toggleTab(mapping, form, request, response); refreshSalesTaxInfo(form); return mapping.findForward(OLEConstants.MAPPING_BASIC); } // Set of actions for which updateEvents should be generated protected static final Set UPDATE_EVENT_ACTIONS; static { String[] updateEventActions = { OLEConstants.SAVE_METHOD, OLEConstants.ROUTE_METHOD, OLEConstants.APPROVE_METHOD, OLEConstants.BLANKET_APPROVE_METHOD }; UPDATE_EVENT_ACTIONS = new HashSet(); for (int i = 0; i < updateEventActions.length; ++i) { UPDATE_EVENT_ACTIONS.add(updateEventActions[i]); } } /** * @param transForm */ protected void processAccountingLineOverrides(KualiAccountingDocumentFormBase transForm) { processAccountingLineOverrides(transForm.getNewSourceLine()); processAccountingLineOverrides(transForm.getNewTargetLine()); if (transForm.hasDocumentId()) { AccountingDocument financialDocument = (AccountingDocument) transForm.getDocument(); processAccountingLineOverrides(financialDocument, financialDocument.getSourceAccountingLines()); processAccountingLineOverrides(financialDocument, financialDocument.getTargetAccountingLines()); } } /** * @param line */ protected void processAccountingLineOverrides(AccountingLine line) { processAccountingLineOverrides(Arrays.asList(new AccountingLine[] { line })); } protected void processAccountingLineOverrides(List accountingLines) { processAccountingLineOverrides(null, accountingLines); } /** * @param accountingLines */ protected void processAccountingLineOverrides(AccountingDocument financialDocument, List accountingLines) { if (!accountingLines.isEmpty()) { for (Iterator i = accountingLines.iterator(); i.hasNext();) { AccountingLine line = (AccountingLine) i.next(); // line.refreshReferenceObject("account"); SpringContext.getBean(PersistenceService.class).retrieveReferenceObjects(line, AccountingLineOverride.REFRESH_FIELDS); AccountingLineOverride.processForOutput(financialDocument, line); } } } /** * @param transDoc * @param transForm * @param lineSet */ protected void processAccountingLines(AccountingDocument transDoc, KualiAccountingDocumentFormBase transForm, String lineSet) { // figure out which set of lines we're looking at List formLines; String pathPrefix; boolean source; if (lineSet.equals(OLEConstants.SOURCE)) { formLines = transDoc.getSourceAccountingLines(); pathPrefix = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.EXISTING_SOURCE_ACCT_LINE_PROPERTY_NAME; source = true; } else { formLines = transDoc.getTargetAccountingLines(); pathPrefix = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.EXISTING_TARGET_ACCT_LINE_PROPERTY_NAME; source = false; } // find and process corresponding form and baselines int index = 0; for (Iterator i = formLines.iterator(); i.hasNext(); index++) { AccountingLine formLine = (AccountingLine) i.next(); // update sales tax required attribute for view // handleSalesTaxRequired(transDoc, formLine, source, false, index); checkSalesTax(transDoc, formLine, source, false, index); } } /** * This method will remove a TargetAccountingLine from a FinancialDocument. This assumes that the user presses the delete button * for a specific accounting line on the document and that the document is represented by a FinancialDocumentFormBase. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward deleteTargetLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase financialDocumentForm = (KualiAccountingDocumentFormBase) form; int deleteIndex = getLineToDelete(request); String errorPath = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.EXISTING_TARGET_ACCT_LINE_PROPERTY_NAME + "[" + deleteIndex + "]"; boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new DeleteAccountingLineEvent( errorPath, financialDocumentForm.getDocument(), ((AccountingDocument) financialDocumentForm.getDocument()).getTargetAccountingLine(deleteIndex), false)); // if the rule evaluation passed, let's delete it if (rulePassed) { deleteAccountingLine(false, financialDocumentForm, deleteIndex); } else { String[] errorParams = new String[] { "target", Integer.toString(deleteIndex + 1) }; GlobalVariables.getMessageMap().putError(errorPath, OLEKeyConstants.ERROR_ACCOUNTINGLINE_DELETERULE_INVALIDACCOUNT, errorParams); } return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * This method will remove a SourceAccountingLine from a FinancialDocument. This assumes that the user presses the delete button * for a specific accounting line on the document and that the document is represented by a FinancialDocumentFormBase. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward deleteSourceLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase financialDocumentForm = (KualiAccountingDocumentFormBase) form; int deleteIndex = getLineToDelete(request); String errorPath = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.EXISTING_SOURCE_ACCT_LINE_PROPERTY_NAME + "[" + deleteIndex + "]"; boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new DeleteAccountingLineEvent( errorPath, financialDocumentForm.getDocument(), ((AccountingDocument) financialDocumentForm.getDocument()).getSourceAccountingLine(deleteIndex), false)); // if the rule evaluation passed, let's delete it if (rulePassed) { deleteAccountingLine(true, financialDocumentForm, deleteIndex); } else { String[] errorParams = new String[] { "source", Integer.toString(deleteIndex + 1) }; GlobalVariables.getMessageMap().putError(errorPath, OLEKeyConstants.ERROR_ACCOUNTINGLINE_DELETERULE_INVALIDACCOUNT, errorParams); } return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * Deletes the source or target accountingLine with the given index from the given form. Assumes that the rule- and form- * validation have already occurred. * * @param isSource * @param financialDocumentForm * @param deleteIndex */ protected void deleteAccountingLine(boolean isSource, KualiAccountingDocumentFormBase financialDocumentForm, int deleteIndex) { if (isSource) { // remove from document financialDocumentForm.getFinancialDocument().getSourceAccountingLines().remove(deleteIndex); } else { // remove from document financialDocumentForm.getFinancialDocument().getTargetAccountingLines().remove(deleteIndex); } // update the doc total AccountingDocument tdoc = (AccountingDocument) financialDocumentForm.getDocument(); if (tdoc instanceof AmountTotaling) { ((FinancialSystemDocumentHeader) financialDocumentForm.getDocument().getDocumentHeader()) .setFinancialDocumentTotalAmount(((AmountTotaling) tdoc).getTotalDollarAmount()); } } /** * This action executes a call to upload CSV accounting line values as TargetAccountingLines for a given transactional document. * The "uploadAccountingLines()" method handles the multi-part request. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward uploadTargetLines(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { // call method that sourceform and destination list uploadAccountingLines(false, form); return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * This action executes a call to upload CSV accounting line values as SourceAccountingLines for a given transactional document. * The "uploadAccountingLines()" method handles the multi-part request. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws FileNotFoundException * @throws IOException */ public ActionForward uploadSourceLines(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws FileNotFoundException, IOException { LOG.info("Uploading source accounting lines"); // call method that sourceform and destination list uploadAccountingLines(true, form); return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * This method determines whether we are uploading source or target lines, and then calls uploadAccountingLines directly on the * document object. This method handles retrieving the actual upload file as an input stream into the document. * * @param isSource * @param form * @throws FileNotFoundException * @throws IOException */ protected void uploadAccountingLines(boolean isSource, ActionForm form) throws FileNotFoundException, IOException { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; List importedLines = null; AccountingDocument financialDocument = tmpForm.getFinancialDocument(); AccountingLineParser accountingLineParser = financialDocument.getAccountingLineParser(); // import the lines String errorPathPrefix = null; try { if (isSource) { errorPathPrefix = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.SOURCE_ACCOUNTING_LINE_ERRORS; FormFile sourceFile = tmpForm.getSourceFile(); checkUploadFile(sourceFile); importedLines = accountingLineParser.importSourceAccountingLines(sourceFile.getFileName(), sourceFile.getInputStream(), financialDocument); } else { errorPathPrefix = OLEConstants.DOCUMENT_PROPERTY_NAME + "." + OLEConstants.TARGET_ACCOUNTING_LINE_ERRORS; FormFile targetFile = tmpForm.getTargetFile(); checkUploadFile(targetFile); importedLines = accountingLineParser.importTargetAccountingLines(targetFile.getFileName(), targetFile.getInputStream(), financialDocument); } } catch (AccountingLineParserException e) { GlobalVariables.getMessageMap().putError(errorPathPrefix, e.getErrorKey(), e.getErrorParameters()); } // add line to list for those lines which were successfully imported if (importedLines != null) { for (Iterator i = importedLines.iterator(); i.hasNext();) { AccountingLine importedLine = (AccountingLine) i.next(); insertAccountingLine(isSource, tmpForm, importedLine); } } } protected void checkUploadFile(FormFile file) { if (file == null) { throw new AccountingLineParserException("invalid (null) upload file", OLEKeyConstants.ERROR_UPLOADFILE_NULL); } } /** * This method will add a TargetAccountingLine to a FinancialDocument. This assumes that the user presses the add button for a * specific accounting line on the document and that the document is represented by a FinancialDocumentFormBase. It first * validates the line for data integrity and then checks appropriate business rules. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward insertTargetLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase financialDocumentForm = (KualiAccountingDocumentFormBase) form; TargetAccountingLine line = financialDocumentForm.getNewTargetLine(); // populate chartOfAccountsCode from account number if accounts cant cross chart and Javascript is turned off //SpringContext.getBean(AccountService.class).populateAccountingLineChartIfNeeded(line); boolean rulePassed = true; // before we check the regular rules we need to check the sales tax rules // TODO: Refactor rules so we no longer have to call this before a copy of the // accountingLine rulePassed &= checkSalesTax((AccountingDocument) financialDocumentForm.getDocument(), line, false, true, 0); // check any business rules rulePassed &= SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent( OLEConstants.NEW_TARGET_ACCT_LINE_PROPERTY_NAME, financialDocumentForm.getDocument(), line)); // if the rule evaluation passed, let's add it if (rulePassed) { // add accountingLine SpringContext.getBean(PersistenceService.class).refreshAllNonUpdatingReferences(line); insertAccountingLine(false, financialDocumentForm, line); // clear the used newTargetLine financialDocumentForm.setNewTargetLine(null); } return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * This action executes an insert of a SourceAccountingLine into a document only after validating the accounting line and * checking any appropriate business rules. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward insertSourceLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase financialDocumentForm = (KualiAccountingDocumentFormBase) form; SourceAccountingLine line = financialDocumentForm.getNewSourceLine(); // populate chartOfAccountsCode from account number if accounts cant cross chart and Javascript is turned off //SpringContext.getBean(AccountService.class).populateAccountingLineChartIfNeeded(line); boolean rulePassed = true; // before we check the regular rules we need to check the sales tax rules // TODO: Refactor rules so we no longer have to call this before a copy of the // accountingLine rulePassed &= checkSalesTax((AccountingDocument) financialDocumentForm.getDocument(), line, true, true, 0); // check any business rules rulePassed &= SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent( OLEConstants.NEW_SOURCE_ACCT_LINE_PROPERTY_NAME, financialDocumentForm.getDocument(), line)); if (rulePassed) { // add accountingLine SpringContext.getBean(PersistenceService.class).refreshAllNonUpdatingReferences(line); insertAccountingLine(true, financialDocumentForm, line); // clear the used newTargetLine financialDocumentForm.setNewSourceLine(null); } return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * Adds the given accountingLine to the appropriate form-related data structures. * * @param isSource * @param financialDocumentForm * @param line */ protected void insertAccountingLine(boolean isSource, KualiAccountingDocumentFormBase financialDocumentForm, AccountingLine line) { AccountingDocument tdoc = financialDocumentForm.getFinancialDocument(); if (isSource) { // add it to the document tdoc.addSourceAccountingLine((SourceAccountingLine) line); // add PK fields to sales tax if needed if (line.isSalesTaxRequired()) { populateSalesTax(line); } // Update the doc total if (tdoc instanceof AmountTotaling) ((FinancialSystemDocumentHeader) financialDocumentForm.getDocument().getDocumentHeader()) .setFinancialDocumentTotalAmount(((AmountTotaling) tdoc).getTotalDollarAmount()); } else { // add it to the document tdoc.addTargetAccountingLine((TargetAccountingLine) line); // add PK fields to sales tax if needed if (line.isSalesTaxRequired()) { populateSalesTax(line); } } } /** * TODO: remove this method once baseline accounting lines has been removed */ protected List deepCopyAccountingLinesList(List originals) { if (originals == null) { return null; } List copiedLines = new ArrayList(); for (int i = 0; i < originals.size(); i++) { copiedLines.add(ObjectUtils.deepCopy((AccountingLine) originals.get(i))); } return copiedLines; } /** * This action changes the value of the hide field in the user interface so that when the page is rendered, the UI knows to show * all of the labels for each of the accounting line values. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward showDetails(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; tmpForm.setHideDetails(false); return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * This method is triggered when the user toggles the show/hide button to "hide" thus making the UI render without any of the * accounting line labels/descriptions showing up underneath the values in the UI. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward hideDetails(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; tmpForm.setHideDetails(true); return mapping.findForward(OLEConstants.MAPPING_BASIC); } /** * Takes care of storing the action form in the User session and forwarding to the balance inquiry report menu action for a * source accounting line. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward performBalanceInquiryForSourceLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { SourceAccountingLine line = this.getSourceAccountingLine(form, request); return performBalanceInquiryForAccountingLine(mapping, form, request, line); } /** * Takes care of storing the action form in the User session and forwarding to the balance inquiry report menu action for a * target accounting line. * * @param mapping * @param form * @param request * @param response * @return ActionForward * @throws Exception */ public ActionForward performBalanceInquiryForTargetLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { int lineIndex = getSelectedLine(request); TargetAccountingLine line = this.getTargetAccountingLine(form, request); return performBalanceInquiryForAccountingLine(mapping, form, request, line); } /** * This method is a helper method that will return a source accounting line. The reason we're making it protected in here is so * that we can override this method in some of the modules. PurchasingActionBase is one of the subclasses that will be * overriding this, because in PurchasingActionBase, we'll need to get the source accounting line using both an item index and * an account index. * * @param form * @param request * @param isSource * @return */ protected SourceAccountingLine getSourceAccountingLine(ActionForm form, HttpServletRequest request) { int lineIndex = getSelectedLine(request); SourceAccountingLine line = (SourceAccountingLine) ObjectUtils.deepCopy( ((KualiAccountingDocumentFormBase) form).getFinancialDocument().getSourceAccountingLine(lineIndex)); return line; } protected TargetAccountingLine getTargetAccountingLine(ActionForm form, HttpServletRequest request) { int lineIndex = getSelectedLine(request); TargetAccountingLine line = (TargetAccountingLine) ((KualiAccountingDocumentFormBase) form) .getFinancialDocument().getTargetAccountingLine(lineIndex); return line; } /** * This method handles preparing all of the accounting line data so that it can be pushed up to the balance inquiries for * populating the search criteria of each. * * @param mapping * @param form * @param request * @param line * @return ActionForward */ protected ActionForward performBalanceInquiryForAccountingLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, AccountingLine line) { // build out base path for return location String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath(); // build out the actual form key that will be used to retrieve the form on refresh String callerDocFormKey = GlobalVariables.getUserSession().addObjectWithGeneratedKey(form); // now add required parameters Properties parameters = new Properties(); parameters.put(OLEConstants.DISPATCH_REQUEST_PARAMETER, OLEConstants.START_METHOD); // need this next param b/c the lookup's return back will overwrite // the original doc form key parameters.put(OLEConstants.BALANCE_INQUIRY_REPORT_MENU_CALLER_DOC_FORM_KEY, callerDocFormKey); parameters.put(OLEConstants.DOC_FORM_KEY, callerDocFormKey); parameters.put(OLEConstants.BACK_LOCATION, basePath + mapping.getPath() + ".do"); if (line.getPostingYear() != null) { parameters.put(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR, line.getPostingYear().toString()); } if (StringUtils.isNotBlank(line.getReferenceOriginCode())) { parameters.put("referenceOriginCode", line.getReferenceOriginCode()); } if (StringUtils.isNotBlank(line.getReferenceNumber())) { parameters.put("referenceNumber", line.getReferenceNumber()); } if (StringUtils.isNotBlank(line.getReferenceTypeCode())) { parameters.put("referenceTypeCode", line.getReferenceTypeCode()); } if (StringUtils.isNotBlank(line.getDebitCreditCode())) { parameters.put("debitCreditCode", line.getDebitCreditCode()); } if (StringUtils.isNotBlank(line.getChartOfAccountsCode())) { parameters.put("chartOfAccountsCode", line.getChartOfAccountsCode()); } if (StringUtils.isNotBlank(line.getAccountNumber())) { parameters.put("accountNumber", line.getAccountNumber()); } if (StringUtils.isNotBlank(line.getFinancialObjectCode())) { parameters.put("financialObjectCode", line.getFinancialObjectCode()); } if (StringUtils.isNotBlank(line.getSubAccountNumber())) { parameters.put("subAccountNumber", line.getSubAccountNumber()); } if (StringUtils.isNotBlank(line.getFinancialSubObjectCode())) { parameters.put("financialSubObjectCode", line.getFinancialSubObjectCode()); } if (StringUtils.isNotBlank(line.getProjectCode())) { parameters.put("projectCode", line.getProjectCode()); } if (StringUtils.isNotBlank(getObjectTypeCodeFromLine(line))) { if (!StringUtils.isBlank(line.getObjectTypeCode())) { parameters.put("objectTypeCode", line.getObjectTypeCode()); } else { line.refreshReferenceObject("objectCode"); parameters.put("objectTypeCode", line.getObjectCode().getFinancialObjectTypeCode()); } } String lookupUrl = UrlFactory .parameterizeUrl(basePath + "/" + OLEConstants.BALANCE_INQUIRY_REPORT_MENU_ACTION, parameters); // register that we're going to come back w/ to this form w/ a refresh methodToCall ((KualiAccountingDocumentFormBase) form).registerEditableProperty(KRADConstants.DISPATCH_REQUEST_PARAMETER); return new ActionForward(lookupUrl, true); } /** * A hook so that most accounting lines - which don't have object types - can have their object type codes used in balance * inquiries * * @param line the line to get the object type code from * @return the object type code the line would use */ protected String getObjectTypeCodeFromLine(AccountingLine line) { line.refreshReferenceObject("objectCode"); return line.getObjectCode().getFinancialObjectTypeCode(); } @Override public ActionForward save(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; ActionForward forward = super.save(mapping, form, request, response); // need to check on sales tax for all the accounting lines checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getSourceAccountingLines()); checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getTargetAccountingLines()); return forward; } @Override public ActionForward approve(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; ActionForward forward = super.approve(mapping, form, request, response); // need to check on sales tax for all the accounting lines checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getSourceAccountingLines()); checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getTargetAccountingLines()); return forward; } @Override public ActionForward route(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; // this.applyCapitalAssetInformation(tmpForm); ActionForward forward = super.route(mapping, form, request, response); checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getSourceAccountingLines()); checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getTargetAccountingLines()); return forward; } @Override public ActionForward blanketApprove(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { KualiAccountingDocumentFormBase tmpForm = (KualiAccountingDocumentFormBase) form; checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getSourceAccountingLines()); checkSalesTaxRequiredAllLines(tmpForm, tmpForm.getFinancialDocument().getTargetAccountingLines()); ActionForward forward = super.blanketApprove(mapping, form, request, response); return forward; } /** * Encapsulate the rule check so we can call it from multiple places * * @param document * @param line * @return true if sales is either not required or it contains sales tax */ protected boolean checkSalesTax(AccountingDocument document, AccountingLine line, boolean source, boolean newLine, int index) { boolean passed = true; if (isSalesTaxRequired(document, line)) { // then set the salesTaxRequired on the accountingLine line.setSalesTaxRequired(true); populateSalesTax(line); // check to see if the sales tax info has been put in passed &= isValidSalesTaxEntered(line, source, newLine, index); } else { //we do not need the saleTax bo for the line otherwise validations will fail. line.setSalesTax(null); } return passed; } /** * This method checks to see if this doctype needs sales tax If it does then it checks to see if the account and object code * require sales tax If it does then it returns true. Note - this is hackish as we shouldn't have to call rules directly from * the action class But we need to in this instance because we are copying the lines before calling rules and need a way to * modify them before they go on * * @param accountingLine * @return true if sales tax check is needed, false otherwise */ protected boolean isSalesTaxRequired(AccountingDocument financialDocument, AccountingLine accountingLine) { boolean required = false; String docType = SpringContext.getBean(DataDictionaryService.class) .getDocumentTypeNameByClass(financialDocument.getClass()); // first we need to check just the doctype to see if it needs the sales tax check ParameterService parameterService = SpringContext.getBean(ParameterService.class); // apply the rule, see if it fails ParameterEvaluator docTypeSalesTaxCheckEvaluator = /*REFACTORME*/SpringContext .getBean(ParameterEvaluatorService.class) .getParameterEvaluator(OleParameterConstants.FINANCIAL_PROCESSING_DOCUMENT.class, APPLICATION_PARAMETER.DOCTYPE_SALES_TAX_CHECK, docType); if (docTypeSalesTaxCheckEvaluator.evaluationSucceeds()) { required = true; } // second we need to check the account and object code combination to see if it needs sales tax if (required) { // get the object code and account String objCd = accountingLine.getFinancialObjectCode(); String account = accountingLine.getAccountNumber(); if (!StringUtils.isEmpty(objCd) && !StringUtils.isEmpty(account)) { String compare = account + ":" + objCd; ParameterEvaluator salesTaxApplicableAcctAndObjectEvaluator = /*REFACTORME*/SpringContext .getBean(ParameterEvaluatorService.class) .getParameterEvaluator(OleParameterConstants.FINANCIAL_PROCESSING_DOCUMENT.class, APPLICATION_PARAMETER.SALES_TAX_APPLICABLE_ACCOUNTS_AND_OBJECT_CODES, compare); if (!salesTaxApplicableAcctAndObjectEvaluator.evaluationSucceeds()) { required = false; } } else { // the two fields are currently empty and we don't need to check yet required = false; } } return required; } /** * This method checks to see if the sales tax information was put into the accounting line * * @param accountingLine * @return true if entered correctly, false otherwise */ protected boolean isValidSalesTaxEntered(AccountingLine accountingLine, boolean source, boolean newLine, int index) { boolean valid = true; DictionaryValidationService dictionaryValidationService = SpringContext .getBean(DictionaryValidationService.class); BusinessObjectService boService = SpringContext.getBean(BusinessObjectService.class); String objCd = accountingLine.getFinancialObjectCode(); String account = accountingLine.getAccountNumber(); SalesTax salesTax = accountingLine.getSalesTax(); String pathPrefix = ""; if (source && !newLine) { pathPrefix = "document." + OLEConstants.EXISTING_SOURCE_ACCT_LINE_PROPERTY_NAME + "[" + index + "]"; } else if (!source && !newLine) { pathPrefix = "document." + OLEConstants.EXISTING_TARGET_ACCT_LINE_PROPERTY_NAME + "[" + index + "]"; } else if (source && newLine) { pathPrefix = OLEConstants.NEW_SOURCE_ACCT_LINE_PROPERTY_NAME; } else if (!source && newLine) { pathPrefix = OLEConstants.NEW_TARGET_ACCT_LINE_PROPERTY_NAME; } GlobalVariables.getMessageMap().addToErrorPath(pathPrefix); if (ObjectUtils.isNull(salesTax)) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.chartOfAccountsCode", ERROR_DOCUMENT_ACCOUNTING_LINE_SALES_TAX_REQUIRED, account, objCd); } else { if (StringUtils.isBlank(salesTax.getChartOfAccountsCode())) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.chartOfAccountsCode", ERROR_REQUIRED, "Chart of Accounts"); } if (StringUtils.isBlank(salesTax.getAccountNumber())) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.accountNumber", ERROR_REQUIRED, "Account Number"); } if (salesTax.getFinancialDocumentGrossSalesAmount() == null) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.financialDocumentGrossSalesAmount", ERROR_REQUIRED, "Gross Sales Amount"); } if (salesTax.getFinancialDocumentTaxableSalesAmount() == null) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.financialDocumentTaxableSalesAmount", ERROR_REQUIRED, "Taxable Sales Amount"); } if (salesTax.getFinancialDocumentSaleDate() == null) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.financialDocumentSaleDate", ERROR_REQUIRED, "Sale Date"); } if (StringUtils.isNotBlank(salesTax.getChartOfAccountsCode()) && StringUtils.isNotBlank(salesTax.getAccountNumber())) { if (boService.getReferenceIfExists(salesTax, "account") == null) { valid &= false; GlobalVariables.getMessageMap().putError("salesTax.accountNumber", ERROR_DOCUMENT_ACCOUNTING_LINE_SALES_TAX_INVALID_ACCOUNT, salesTax.getChartOfAccountsCode(), salesTax.getAccountNumber()); } } if (!valid) { GlobalVariables.getMessageMap().putError("salesTax.chartOfAccountsCode", ERROR_DOCUMENT_ACCOUNTING_LINE_SALES_TAX_REQUIRED, account, objCd); } } GlobalVariables.getMessageMap().removeFromErrorPath(pathPrefix); return valid; } /** * This method removes the sales tax information from a line that no longer requires it * * @param accountingLine */ protected void removeSalesTax(AccountingLine accountingLine) { SalesTax salesTax = accountingLine.getSalesTax(); if (ObjectUtils.isNotNull(salesTax)) { accountingLine.setSalesTax(null); } } /** * This method checks to see if the given accounting needs sales tax and if it does it sets the salesTaxRequired variable on the * line If it doesn't and it has it then it removes the sales tax information from the line This method is called from the * execute() on all accounting lines that have been edited or lines that have already been added to the document, not on new * lines * * @param transDoc * @param formLine * @param baseLine */ protected void handleSalesTaxRequired(AccountingDocument transDoc, AccountingLine formLine, boolean source, boolean newLine, int index) { boolean salesTaxRequired = isSalesTaxRequired(transDoc, formLine); if (salesTaxRequired) { formLine.setSalesTaxRequired(true); populateSalesTax(formLine); } else if (!salesTaxRequired && hasSalesTaxBeenEntered(formLine, source, newLine, index)) { // remove it if it has been added but is no longer required removeSalesTax(formLine); formLine.setSalesTax(null); } if (!salesTaxRequired) { formLine.setSalesTax(null); } } protected boolean hasSalesTaxBeenEntered(AccountingLine accountingLine, boolean source, boolean newLine, int index) { boolean entered = true; String objCd = accountingLine.getFinancialObjectCode(); String account = accountingLine.getAccountNumber(); SalesTax salesTax = accountingLine.getSalesTax(); if (ObjectUtils.isNull(salesTax)) { return false; } if (StringUtils.isBlank(salesTax.getChartOfAccountsCode())) { entered &= false; } if (StringUtils.isBlank(salesTax.getAccountNumber())) { entered &= false; } if (salesTax.getFinancialDocumentGrossSalesAmount() == null) { entered &= false; } if (salesTax.getFinancialDocumentTaxableSalesAmount() == null) { entered &= false; } if (salesTax.getFinancialDocumentSaleDate() == null) { entered &= false; } return entered; } /** * This method is called from the createDocument and processes through all the accouting lines and checks to see if they need * sales tax fields * * @param kualiDocumentFormBase * @param baselineSourceLines */ protected void handleSalesTaxRequiredAllLines(KualiDocumentFormBase kualiDocumentFormBase, List<AccountingLine> baselineAcctingLines) { AccountingDocument accoutingDocument = (AccountingDocument) kualiDocumentFormBase.getDocument(); int index = 0; for (AccountingLine accountingLine : baselineAcctingLines) { boolean source = false; if (accountingLine.isSourceAccountingLine()) { source = true; } handleSalesTaxRequired(accoutingDocument, accountingLine, source, false, index); index++; } } protected boolean checkSalesTaxRequiredAllLines(KualiDocumentFormBase kualiDocumentFormBase, List<AccountingLine> baselineAcctingLines) { AccountingDocument accoutingDocument = (AccountingDocument) kualiDocumentFormBase.getDocument(); boolean passed = true; int index = 0; for (AccountingLine accountingLine : baselineAcctingLines) { boolean source = false; if (accountingLine.isSourceAccountingLine()) { source = true; } passed &= checkSalesTax(accoutingDocument, accountingLine, source, false, index); index++; } return passed; } /** * This method refreshes the sales tax fields on a refresh or tab toggle so that all the information that was there before is * still there after a state change * * @param form */ protected void refreshSalesTaxInfo(ActionForm form) { KualiAccountingDocumentFormBase accountingForm = (KualiAccountingDocumentFormBase) form; AccountingDocument document = (AccountingDocument) accountingForm.getDocument(); List sourceLines = document.getSourceAccountingLines(); List targetLines = document.getTargetAccountingLines(); handleSalesTaxRequiredAllLines(accountingForm, sourceLines); handleSalesTaxRequiredAllLines(accountingForm, targetLines); AccountingLine newTargetLine = accountingForm.getNewTargetLine(); AccountingLine newSourceLine = accountingForm.getNewSourceLine(); if (newTargetLine != null) { handleSalesTaxRequired(document, newTargetLine, false, true, 0); } if (newSourceLine != null) { handleSalesTaxRequired(document, newSourceLine, true, true, 0); } } /** * This method populates the sales tax for a given accounting line with the appropriate primary key fields from the accounting * line since OJB won't do it automatically for us * * @param line */ protected void populateSalesTax(AccountingLine line) { SalesTax salesTax = line.getSalesTax(); if (ObjectUtils.isNotNull(salesTax)) { salesTax.setDocumentNumber(line.getDocumentNumber()); salesTax.setFinancialDocumentLineTypeCode(line.getFinancialDocumentLineTypeCode()); salesTax.setFinancialDocumentLineNumber(line.getSequenceNumber()); } } @Override public ActionForward performLookup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { // parse out the business object name from our methodToCall parameter String fullParameter = (String) request.getAttribute(OLEConstants.METHOD_TO_CALL_ATTRIBUTE); String boClassName = StringUtils.substringBetween(fullParameter, OLEConstants.METHOD_TO_CALL_BOPARM_LEFT_DEL, OLEConstants.METHOD_TO_CALL_BOPARM_RIGHT_DEL); if (!StringUtils.equals(boClassName, GeneralLedgerPendingEntry.class.getName())) { return super.performLookup(mapping, form, request, response); } String path = super.performLookup(mapping, form, request, response).getPath(); path = path.replaceFirst(OLEConstants.LOOKUP_ACTION, OLEConstants.GL_MODIFIED_INQUIRY_ACTION); return new ActionForward(path, true); } }