Java tutorial
/* * The Kuali Financial System, a comprehensive financial management system for higher education. * * Copyright 2005-2014 The Kuali Foundation * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, either version 3 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.kuali.kfs.module.purap.document.authorization; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Set; import org.apache.commons.lang.StringUtils; import org.kuali.kfs.module.purap.PurapParameterConstants; import org.kuali.kfs.module.purap.PurapPropertyConstants; import org.kuali.kfs.module.purap.businessobject.PurApAccountingLine; import org.kuali.kfs.module.purap.businessobject.PurApItem; import org.kuali.kfs.module.purap.document.PaymentRequestDocument; import org.kuali.kfs.module.purap.document.PurchaseOrderDocument; import org.kuali.kfs.module.purap.document.PurchasingAccountsPayableDocument; import org.kuali.kfs.module.purap.document.PurchasingAccountsPayableDocumentBase; import org.kuali.kfs.module.purap.document.RequisitionDocument; import org.kuali.kfs.module.purap.document.service.PurapService; import org.kuali.kfs.sys.KFSPropertyConstants; import org.kuali.kfs.sys.businessobject.AccountingLine; import org.kuali.kfs.sys.context.SpringContext; import org.kuali.kfs.sys.document.AccountingDocument; import org.kuali.kfs.sys.document.authorization.AccountingLineAuthorizerBase; import org.kuali.kfs.sys.document.authorization.FinancialSystemTransactionalDocumentAuthorizerBase; import org.kuali.kfs.sys.document.authorization.FinancialSystemTransactionalDocumentPresentationController; import org.kuali.kfs.sys.document.web.AccountingLineRenderingContext; import org.kuali.rice.coreservice.framework.parameter.ParameterService; import org.kuali.rice.kim.api.identity.Person; import org.kuali.rice.kns.datadictionary.TransactionalDocumentEntry; import org.kuali.rice.kns.document.authorization.DocumentAuthorizer; import org.kuali.rice.kns.service.DataDictionaryService; import org.kuali.rice.krad.document.DocumentPresentationController; /** * Authorizer which deals with financial processing document issues, specifically sales tax lines on documents * This class utilizes the new accountingLine model. */ public class PurapAccountingLineAuthorizer extends AccountingLineAuthorizerBase { /** * Overrides the method in AccountingLineAuthorizerBase so that the add button would * have the line item number in addition to the rest of the insertxxxx String for * methodToCall when the user clicks on the add button. * * @param accountingLine * @param accountingLineProperty * @return */ @Override protected String getAddMethod(AccountingLine accountingLine, String accountingLineProperty) { final String infix = getActionInfixForNewAccountingLine(accountingLine, accountingLineProperty); String lineNumber = null; if (accountingLineProperty.equals(PurapPropertyConstants.ACCOUNT_DISTRIBUTION_NEW_SRC_LINE)) { lineNumber = "-2"; } else { lineNumber = StringUtils.substringBetween(accountingLineProperty, "[", "]"); } return "insert" + infix + "Line.line" + lineNumber + "." + "anchoraccounting" + infix + "Anchor"; } /** * Overrides the method in AccountingLineAuthorizerBase so that the delete button would have both * the line item number and the accounting line number for methodToCall when the user clicks on * the delete button. * * @see org.kuali.kfs.sys.document.authorization.AccountingLineAuthorizerBase#getDeleteLineMethod(org.kuali.kfs.sys.businessobject.AccountingLine, java.lang.String, java.lang.Integer) */ @Override protected String getDeleteLineMethod(AccountingLine accountingLine, String accountingLineProperty, Integer accountingLineIndex) { final String infix = getActionInfixForExtantAccountingLine(accountingLine, accountingLineProperty); String lineNumber = StringUtils.substringBetween(accountingLineProperty, "item[", "].sourceAccountingLine"); if (lineNumber == null) { lineNumber = "-2"; } String accountingLineNumber = StringUtils.substringBetween(accountingLineProperty, "sourceAccountingLine[", "]"); return "delete" + infix + "Line.line" + lineNumber + ":" + accountingLineNumber + ".anchoraccounting" + infix + "Anchor"; } /** * Overrides the method in AccountingLineAuthorizerBase so that the balance inquiry button would * have both the line item number and the accounting line number for methodToCall when the user * clicks on the balance inquiry button. * @see org.kuali.kfs.sys.document.authorization.AccountingLineAuthorizerBase#getBalanceInquiryMethod(org.kuali.kfs.sys.businessobject.AccountingLine, java.lang.String, java.lang.Integer) */ @Override protected String getBalanceInquiryMethod(AccountingLine accountingLine, String accountingLineProperty, Integer accountingLineIndex) { final String infix = getActionInfixForNewAccountingLine(accountingLine, accountingLineProperty); String lineNumber = StringUtils.substringBetween(accountingLineProperty, "item[", "].sourceAccountingLine"); if (lineNumber == null) { lineNumber = "-2"; } String accountingLineNumber = StringUtils.substringBetween(accountingLineProperty, "sourceAccountingLine[", "]"); return "performBalanceInquiryFor" + infix + "Line.line" + ":" + lineNumber + ":" + accountingLineNumber + ".anchoraccounting" + infix + "existingLineLineAnchor" + accountingLineNumber; } /** * @see org.kuali.kfs.sys.document.authorization.AccountingLineAuthorizerBase#getUnviewableBlocks(org.kuali.kfs.sys.document.AccountingDocument, org.kuali.kfs.sys.businessobject.AccountingLine, boolean, org.kuali.rice.kim.api.identity.Person) */ @Override public Set<String> getUnviewableBlocks(AccountingDocument accountingDocument, AccountingLine accountingLine, boolean newLine, Person currentUser) { Set<String> unviewableBlocks = super.getUnviewableBlocks(accountingDocument, accountingLine, newLine, currentUser); if (showAmountOnly(accountingDocument)) { unviewableBlocks.add(KFSPropertyConstants.PERCENT); } else { unviewableBlocks.add(KFSPropertyConstants.AMOUNT); } return unviewableBlocks; } private boolean showAmountOnly(AccountingDocument accountingDocument) { PurapService purapService = SpringContext.getBean(PurapService.class); if (accountingDocument instanceof PurchasingAccountsPayableDocument) { if (purapService.isFullDocumentEntryCompleted((PurchasingAccountsPayableDocument) accountingDocument)) { return true; } } return false; } /** * * @param accountingDocument * @return */ private FinancialSystemTransactionalDocumentPresentationController getPresentationController( AccountingDocument accountingDocument) { final Class<? extends DocumentPresentationController> presentationControllerClass = ((TransactionalDocumentEntry) SpringContext .getBean(DataDictionaryService.class).getDataDictionary() .getDictionaryObjectEntry(accountingDocument.getClass().getName())) .getDocumentPresentationControllerClass(); FinancialSystemTransactionalDocumentPresentationController presentationController = null; try { presentationController = (FinancialSystemTransactionalDocumentPresentationController) presentationControllerClass .newInstance(); } catch (InstantiationException ie) { throw new RuntimeException("Cannot instantiate instance of presentation controller for " + accountingDocument.getClass().getName(), ie); } catch (IllegalAccessException iae) { throw new RuntimeException("Cannot instantiate instance of presentation controller for " + accountingDocument.getClass().getName(), iae); } return presentationController; } /** * * @param accountingDocument * @return */ @Override protected FinancialSystemTransactionalDocumentAuthorizerBase getDocumentAuthorizer( AccountingDocument accountingDocument) { final Class<? extends DocumentAuthorizer> documentAuthorizerClass = ((TransactionalDocumentEntry) SpringContext .getBean(DataDictionaryService.class).getDataDictionary() .getDictionaryObjectEntry(accountingDocument.getClass().getName())).getDocumentAuthorizerClass(); FinancialSystemTransactionalDocumentAuthorizerBase documentAuthorizer = null; try { documentAuthorizer = (FinancialSystemTransactionalDocumentAuthorizerBase) documentAuthorizerClass .newInstance(); } catch (InstantiationException ie) { throw new RuntimeException("Cannot instantiate instance of document authorizer for " + accountingDocument.getClass().getName(), ie); } catch (IllegalAccessException iae) { throw new RuntimeException("Cannot instantiate instance of document authorizer for " + accountingDocument.getClass().getName(), iae); } return documentAuthorizer; } @Override public boolean isGroupEditable(AccountingDocument accountingDocument, List<? extends AccountingLineRenderingContext> accountingLineRenderingContexts, Person currentUser) { boolean isEditable = super.isGroupEditable(accountingDocument, accountingLineRenderingContexts, currentUser); if (isEditable) { if (accountingLineRenderingContexts.size() == 0) { return false; } isEditable = allowAccountingLinesAreEditable(accountingDocument, accountingLineRenderingContexts.get(0).getAccountingLine()); } return isEditable; } @Override public boolean determineEditPermissionOnField(AccountingDocument accountingDocument, AccountingLine accountingLine, String accountingLineCollectionProperty, String fieldName, boolean editablePage) { // the fields in a new line should be always editable if (accountingLine.getSequenceNumber() == null) { return true; } boolean isEditable = super.determineEditPermissionOnField(accountingDocument, accountingLine, accountingLineCollectionProperty, fieldName, editablePage); if (isEditable) { isEditable = allowAccountingLinesAreEditable(accountingDocument, accountingLine); } return isEditable; } @Override public boolean determineEditPermissionOnLine(AccountingDocument accountingDocument, AccountingLine accountingLine, String accountingLineCollectionProperty, boolean currentUserIsDocumentInitiator, boolean pageIsEditable) { boolean isEditable = super.determineEditPermissionOnLine(accountingDocument, accountingLine, accountingLineCollectionProperty, currentUserIsDocumentInitiator, pageIsEditable); if (isEditable) { isEditable = allowAccountingLinesAreEditable(accountingDocument, accountingLine); } return (isEditable && pageIsEditable); } /** * This method checks whether the accounting lines are editable for a specific item type. * */ protected boolean allowAccountingLinesAreEditable(AccountingDocument accountingDocument, AccountingLine accountingLine) { PurApAccountingLine purapAccount = (PurApAccountingLine) accountingLine; @SuppressWarnings("rawtypes") Class clazz = getPurapDocumentClass(accountingDocument); if (clazz == null) { return true; } //if not calculated yet then the line is editable PurchasingAccountsPayableDocumentBase purapDoc = (PurchasingAccountsPayableDocumentBase) accountingDocument; if (!purapDoc.isCalculated()) { return true; } Collection<String> restrictedItemTypesList = new ArrayList<String>( SpringContext.getBean(ParameterService.class).getParameterValuesAsString(clazz, PurapParameterConstants.PURAP_ITEM_TYPES_RESTRICTING_ACCOUNT_EDIT)); // This call determines a new special case in which an item marked for trade-in cannot have editable accounting lines // once the calculate button image is clicked, even if the accounting line has not been saved yet. boolean retval = true; retval = isEditableBasedOnTradeInRestriction(accountingDocument, accountingLine); if (restrictedItemTypesList != null && purapAccount.getPurapItem() != null) { return (!restrictedItemTypesList.contains(purapAccount.getPurapItem().getItemTypeCode()) && retval); } else if (restrictedItemTypesList != null && purapAccount.getPurapItem() == null) { return retval; } else { return true; } } /** * Find the item to which an accounting line belongs. Convenience/Utility method. * * Some methods that require an accounting line with a purApItem attached were getting accounting lines * passed in that did not yet have a purApItem. I needed a way to match the accounting line to the * proper item. * * @param accountingDocument the document holding both the accounting line and the item to which the * accounting line is attached * @param accountingLine the accounting line of interest, for which a containing item should be found * @return the item to which the incoming accounting line is attached */ protected PurApItem findTheItemForAccountingLine(AccountingDocument accountingDocument, AccountingLine accountingLine) { PurApItem retval = null; List<PurApItem> listItems = null; scan: { if (accountingDocument instanceof PurchasingAccountsPayableDocumentBase) { listItems = ((PurchasingAccountsPayableDocumentBase) accountingDocument).getItems(); // loop through all items in the document to see if the item has an accounting line that // matches the one passed in for (PurApItem oneItem : listItems) { List<PurApAccountingLine> acctLines = oneItem.getSourceAccountingLines(); for (PurApAccountingLine oneAcctLine : acctLines) { // we want to compare the exact same memory location, not the contents if (oneAcctLine == accountingLine) { retval = oneItem; // we found it, so I can stop altogether. break scan; } } } } } return retval; } /** * Handles a restriction on accounting lines assigned to trade-in items. * If the accounting Line is for a trade-in item type, and the accounting line has contents, * the user is not allowed to change the contents of the calculated values. * * The trade-in may not yet have a sequence number, so the old way of relying solely on sequence * number (in method super.approvedForUnqualifiedEditing() is incomplete, and needs this extra check * for trade-ins. * * @param accountingLine the accounting line being examined * @return whether the accounting line is editable according to the trade-in/non-empty restriction */ private boolean isEditableBasedOnTradeInRestriction(AccountingDocument accountingDocument, AccountingLine accountingLine) { boolean retval = true; // if the accounting Line is for a trade-In, and the line has contents, the user is not allowed to // change the contents of the calculated values if ((accountingLine != null) && (accountingLine instanceof PurApAccountingLine)) { PurApItem purApItem = (((PurApAccountingLine) accountingLine)).getPurapItem(); // this small block is to allow for another way to get to the purApItem if the // incoming accounting line does not yet have a purApItem attached. Calling it is not // completely necessary any more, unless/until the functional team members decide to // add more item types to the read-only accounting lines list. if (purApItem == null) { purApItem = findTheItemForAccountingLine(accountingDocument, accountingLine); } if (purApItem != null) { String itemTypeCode = purApItem.getItemTypeCode(); if (itemTypeCode.toUpperCase().equalsIgnoreCase(PurapParameterConstants.PURAP_ITEM_TYPE_TRDI)) { // does the line have any contents? if so, then the user cannot edit them if ((accountingLine.getChartOfAccountsCode() != null) || (accountingLine.getAccountNumber() != null) || (accountingLine.getFinancialObjectCode() != null)) { retval = false; } } // there has been a call to "if (purApItem.getItemAssignedToTradeInIndicator()) {" here // that required the earlier use of findTheItemForAccountingLine() } } return retval; } @SuppressWarnings("rawtypes") private Class getPurapDocumentClass(AccountingDocument accountingDocument) { if (accountingDocument instanceof RequisitionDocument) { return RequisitionDocument.class; } else if (accountingDocument instanceof PurchaseOrderDocument) { return PurchaseOrderDocument.class; } else if (accountingDocument instanceof PaymentRequestDocument) { return PaymentRequestDocument.class; } else { return null; } } /** * Determines if the given line is editable, no matter what a KIM check would say about line editability. In the default case, * any accounting line is editable - minus KIM check - when the document is PreRoute, or if the line is a new line * * This overriding implementation is required because the Purap module has a new restriction that requires * that an accounting line for a Trade-In item cannot be manually editable, even if not yet saved ("not yet saved" means it has * no sequence number). Therefore, the base implementation that determines editability on the sequence number alone has to be * preceded by a check that declares ineligible for editing if it is a trade-in. * * @see org.kuali.kfs.module.purap.document.authorization.PurapAccountingLineAuthorizer#allowAccountingLinesAreEditable(AccountingDocument, AccountingLine) * * @param accountingDocument the accounting document the line is or wants to be associated with * @param accountingLine the accounting line itself * @param accountingLineCollectionProperty the collection the accounting line is or would be part of * @param currentUserIsDocumentInitiator is the current user the initiator of the document? * @return true if the line as a whole can be edited without the KIM check, false otherwise */ @Override protected boolean approvedForUnqualifiedEditing(AccountingDocument accountingDocument, AccountingLine accountingLine, String accountingLineCollectionProperty, boolean currentUserIsDocumentInitiator) { boolean retval = true; retval = isEditableBasedOnTradeInRestriction(accountingDocument, accountingLine); if (retval) { retval = super.approvedForUnqualifiedEditing(accountingDocument, accountingLine, accountingLineCollectionProperty, currentUserIsDocumentInitiator); } return retval; } }