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.fp.document.web.struts; import static org.kuali.kfs.sys.KFSConstants.VOUCHER_LINE_HELPER_CREDIT_PROPERTY_NAME; import static org.kuali.kfs.sys.KFSConstants.VOUCHER_LINE_HELPER_DEBIT_PROPERTY_NAME; import java.sql.Date; import java.util.ArrayList; import java.util.List; import java.util.Map; import javax.servlet.http.HttpServletRequest; import org.apache.commons.lang.StringUtils; import org.kuali.kfs.coa.businessobject.AccountingPeriod; import org.kuali.kfs.coa.businessobject.ObjectCode; import org.kuali.kfs.coa.businessobject.SubObjectCode; import org.kuali.kfs.coa.service.AccountingPeriodService; import org.kuali.kfs.fp.businessobject.VoucherAccountingLineHelper; import org.kuali.kfs.fp.businessobject.VoucherAccountingLineHelperBase; import org.kuali.kfs.fp.document.VoucherDocument; import org.kuali.kfs.sys.KFSConstants; import org.kuali.kfs.sys.KFSKeyConstants; import org.kuali.kfs.sys.KFSPropertyConstants; import org.kuali.kfs.sys.businessobject.SourceAccountingLine; import org.kuali.kfs.sys.context.SpringContext; import org.kuali.kfs.sys.document.AmountTotaling; import org.kuali.kfs.sys.web.struts.KualiAccountingDocumentFormBase; import org.kuali.rice.core.api.datetime.DateTimeService; import org.kuali.rice.core.api.util.type.KualiDecimal; import org.kuali.rice.core.web.format.CurrencyFormatter; import org.kuali.rice.krad.util.GlobalVariables; import org.kuali.rice.krad.util.ObjectUtils; /** * This class is the Struts specific form object that works in conjunction with the pojo utilities to build the UI for Voucher * Document instances. This class is unique in that it leverages a helper data structure called the * <code>{@link VoucherAccountingLineHelper}</code> because Voucher documents, under some/none conditions, presents the user with * a debit and credit column for amount entry. New accounting lines use specific credit and debit amount fields b/c the new line is * explicitly known; however, already existing accounting lines need to exist within a list with ordering that matches the * accounting lines source list. */ public class VoucherForm extends KualiAccountingDocumentFormBase { protected List accountingPeriods; protected KualiDecimal newSourceLineDebit; protected KualiDecimal newSourceLineCredit; protected List voucherLineHelpers; protected String selectedAccountingPeriod; /** * Supplements a constructor for this voucher class */ public VoucherForm() { populateDefaultSelectedAccountingPeriod(); setNewSourceLineCredit(KualiDecimal.ZERO); setNewSourceLineDebit(KualiDecimal.ZERO); setVoucherLineHelpers(new ArrayList()); } /** * sets initial selected accounting period to current period */ public void populateDefaultSelectedAccountingPeriod() { Date date = SpringContext.getBean(DateTimeService.class).getCurrentSqlDate(); AccountingPeriod accountingPeriod = SpringContext.getBean(AccountingPeriodService.class).getByDate(date); StringBuffer sb = new StringBuffer(); sb.append(accountingPeriod.getUniversityFiscalPeriodCode()); sb.append(accountingPeriod.getUniversityFiscalYear()); setSelectedAccountingPeriod(sb.toString()); } /** * Overrides the parent to call super.populate and then to call the two methods that are specific to loading the two select * lists on the page. In addition, this also makes sure that the credit and debit amounts are filled in for situations where * validation errors occur and the page reposts. * * @see org.kuali.rice.kns.web.struts.pojo.PojoForm#populate(javax.servlet.http.HttpServletRequest) */ @Override public void populate(HttpServletRequest request) { super.populate(request); // populate the drop downs if (KFSConstants.RETURN_METHOD_TO_CALL.equals(getMethodToCall())) { String selectedPeriod = (StringUtils .defaultString(request.getParameter(KFSPropertyConstants.UNIVERSITY_FISCAL_PERIOD_CODE)) + StringUtils.defaultString(request.getParameter(KFSPropertyConstants.UNIVERSITY_FISCAL_YEAR))); if (StringUtils.isNotBlank(selectedPeriod)) { setSelectedAccountingPeriod(selectedPeriod); } } populateAccountingPeriodListForRendering(); // we don't want to do this if we are just reloading the document if (StringUtils.isBlank(getMethodToCall()) || !getMethodToCall().equals(KFSConstants.RELOAD_METHOD_TO_CALL)) { // make sure the amount fields are populated appropriately when in debit/credit amount mode populateCreditAndDebitAmounts(); } } /** * util method to get postingYear out of selectedAccountingPeriod * * @return Integer */ protected Integer getSelectedPostingYear() { Integer postingYear = null; if (StringUtils.isNotBlank(getSelectedAccountingPeriod())) { postingYear = new Integer(StringUtils.right(getSelectedAccountingPeriod(), 4)); } return postingYear; } /** * util method to get posting period code out of selectedAccountingPeriod * * @return String */ protected String getSelectedPostingPeriodCode() { String periodCode = null; String selectedPeriod = getSelectedAccountingPeriod(); if (StringUtils.isNotBlank(selectedPeriod)) { periodCode = StringUtils.left(selectedPeriod, 2); } return periodCode; } /** * Helper method to make casting easier * * @return VoucherDocument */ public VoucherDocument getVoucherDocument() { return (VoucherDocument) getDocument(); } /** * Override the parent, to push the chosen accounting period and balance type down into the source accounting line object. In * addition, check the balance type to see if it's the "External Encumbrance" balance and alter the encumbrance update code on * the accounting line appropriately. * * @see org.kuali.rice.kns.web.struts.form.KualiTransactionalDocumentFormBase#populateSourceAccountingLine(org.kuali.rice.krad.bo.SourceAccountingLine) */ @Override public void populateSourceAccountingLine(SourceAccountingLine sourceLine, String accountingLinePropertyName, Map parameterMap) { super.populateSourceAccountingLine(sourceLine, accountingLinePropertyName, parameterMap); // set the chosen accounting period into the line String selectedAccountingPeriod = getSelectedAccountingPeriod(); if (StringUtils.isNotBlank(selectedAccountingPeriod)) { Integer postingYear = getSelectedPostingYear(); sourceLine.setPostingYear(postingYear); if (ObjectUtils.isNull(sourceLine.getObjectCode())) { sourceLine.setObjectCode(new ObjectCode()); } sourceLine.getObjectCode().setUniversityFiscalYear(postingYear); if (ObjectUtils.isNull(sourceLine.getSubObjectCode())) { sourceLine.setSubObjectCode(new SubObjectCode()); } sourceLine.getSubObjectCode().setUniversityFiscalYear(postingYear); } } /** * This method retrieves the list of valid accounting periods to display. * * @return List */ public List getAccountingPeriods() { return accountingPeriods; } /** * This method sets the list of valid accounting periods to display. * * @param accountingPeriods */ public void setAccountingPeriods(List accountingPeriods) { this.accountingPeriods = accountingPeriods; } /** * This method returns the reversal date in the format MMM d, yyyy. * * @return String */ public String getFormattedReversalDate() { return formatReversalDate(getVoucherDocument().getReversalDate()); } /** * This method retrieves the selectedAccountingPeriod. * * @return String */ public String getSelectedAccountingPeriod() { return selectedAccountingPeriod; } /** * @return AccountingPeriod associated with the currently selected period */ public AccountingPeriod getAccountingPeriod() { AccountingPeriod period = null; if (!StringUtils.isBlank(getSelectedAccountingPeriod())) { period = SpringContext.getBean(AccountingPeriodService.class) .getByPeriod(getSelectedPostingPeriodCode(), getSelectedPostingYear()); } return period; } /** * This method sets the selectedAccountingPeriod. * * @param selectedAccountingPeriod */ public void setSelectedAccountingPeriod(String selectedAccountingPeriod) { this.selectedAccountingPeriod = selectedAccountingPeriod; } /** * Accessor to the list of <code>{@link VoucherAccountingLineHelper}</code> instances. This method retrieves the list of * helper line objects for the form. * * @return List */ public List getVoucherLineHelpers() { return voucherLineHelpers; } /** * This method retrieves the proper voucher helper line data structure at the passed in list index so that it matches up with * the correct accounting line at that index. * * @param index * @return VoucherAccountingLineHelper */ public VoucherAccountingLineHelper getVoucherLineHelper(int index) { while (getVoucherLineHelpers().size() <= index) { getVoucherLineHelpers().add(new VoucherAccountingLineHelperBase()); } return (VoucherAccountingLineHelper) getVoucherLineHelpers().get(index); } /** * This method sets the list of helper lines for the form. * * @param voucherLineHelpers */ public void setVoucherLineHelpers(List voucherLineHelpers) { this.voucherLineHelpers = voucherLineHelpers; } /** * This method retrieves the credit amount of the new accounting line that was added. * * @return KualiDecimal */ public KualiDecimal getNewSourceLineCredit() { return newSourceLineCredit; } /** * This method sets the credit amount of the new accounting line that was added. * * @param newSourceLineCredit */ public void setNewSourceLineCredit(KualiDecimal newSourceLineCredit) { this.newSourceLineCredit = newSourceLineCredit; } /** * This method retrieves the debit amount of the new accounting line that was added. * * @return KualiDecimal */ public KualiDecimal getNewSourceLineDebit() { return newSourceLineDebit; } /** * This method sets the debit amount of the new accounting line that was added. * * @param newSourceLineDebit */ public void setNewSourceLineDebit(KualiDecimal newSourceLineDebit) { this.newSourceLineDebit = newSourceLineDebit; } /** * This method retrieves the voucher's debit total formatted as currency. * * @return String */ public String getCurrencyFormattedDebitTotal() { return (String) new CurrencyFormatter().format(getVoucherDocument().getDebitTotal()); } /** * This method retrieves the voucher's credit total formatted as currency. * * @return String */ public String getCurrencyFormattedCreditTotal() { return (String) new CurrencyFormatter().format(getVoucherDocument().getCreditTotal()); } /** * This method retrieves the voucher's total formatted as currency. * * @return String */ public String getCurrencyFormattedTotal() { return (String) new CurrencyFormatter() .format(((AmountTotaling) getVoucherDocument()).getTotalDollarAmount()); } /** * This method retrieves all of the "open for posting" accounting periods and prepares them to be rendered in a dropdown UI * component. */ public void populateAccountingPeriodListForRendering() { // grab the list of valid accounting periods ArrayList accountingPeriods = new ArrayList( SpringContext.getBean(AccountingPeriodService.class).getOpenAccountingPeriods()); // set into the form for rendering setAccountingPeriods(accountingPeriods); // set the chosen accounting period into the form populateSelectedVoucherAccountingPeriod(); } /** * This method parses the accounting period value from the form and builds a basic AccountingPeriod object so that the voucher * is properly persisted with the accounting period set for it. */ protected void populateSelectedVoucherAccountingPeriod() { if (StringUtils.isNotBlank(getSelectedAccountingPeriod())) { AccountingPeriod ap = new AccountingPeriod(); ap.setUniversityFiscalPeriodCode(getSelectedPostingPeriodCode()); ap.setUniversityFiscalYear(getSelectedPostingYear()); getFinancialDocument().setAccountingPeriod(ap); } } /** * If the balance type is an offset generation balance type, then the user is able to enter the amount as either a debit or a * credit, otherwise, they only need to deal with the amount field in this case we always need to update the underlying bo so * that the debit/credit code along with the amount, is properly set. */ protected void populateCreditAndDebitAmounts() { processDebitAndCreditForNewSourceLine(); processDebitAndCreditForAllSourceLines(); } /** * This method uses the newly entered debit and credit amounts to populate the new source line that is to be added to the * voucher document. * * @return boolean True if the processing was successful, false otherwise. */ protected boolean processDebitAndCreditForNewSourceLine() { // using debits and credits supplied, populate the new source accounting line's amount and debit/credit code appropriately boolean passed = processDebitAndCreditForSourceLine(getNewSourceLine(), newSourceLineDebit, newSourceLineCredit, KFSConstants.NEGATIVE_ONE); return passed; } /** * This method iterates through all of the source accounting lines associated with the voucher doc and accounts for any changes * to the credit and debit amounts, populate the source lines' amount and debit/credit code fields appropriately, so that they * can be persisted accurately. This accounts for the fact that users may change the amounts and/or flip-flop the credit debit * amounts on any accounting line after the initial add of the accounting line. * * @return boolean */ protected boolean processDebitAndCreditForAllSourceLines() { VoucherDocument vDoc = getVoucherDocument(); // iterate through all of the source accounting lines boolean validProcessing = true; for (int i = 0; i < vDoc.getSourceAccountingLines().size(); i++) { // retrieve the proper business objects from the form SourceAccountingLine sourceLine = vDoc.getSourceAccountingLine(i); VoucherAccountingLineHelper voucherLineHelper = getVoucherLineHelper(i); // now process the amounts and the line // we want to process all lines, some may be invalid b/c of dual amount values, but this method will handle // only processing the valid ones, that way we are guaranteed that values in the valid lines carry over through the // post and invalid ones do not alter the underlying business object validProcessing &= processDebitAndCreditForSourceLine(sourceLine, voucherLineHelper.getDebit(), voucherLineHelper.getCredit(), i); } return validProcessing; } /** * This method checks the debit and credit attributes passed in, figures out which one has a value, and sets the source * accounting line's amount and debit/credit attribute appropriately. It assumes that if it finds something in the debit field, * it's a debit entry, otherwise it's a credit entry. If a user enters a value into both fields, it will assume the debit value, * then when the br eval framework applies the "add" rule, it will bomb out. If first checks to make sure that there isn't a * value in both the credit and debit columns. * * @param sourceLine * @param debitAmount * @param creditAmount * @param index if -1, then its a new line, if not -1 then it's an existing line * @return boolean True if the processing was successful, false otherwise. */ protected boolean processDebitAndCreditForSourceLine(SourceAccountingLine sourceLine, KualiDecimal debitAmount, KualiDecimal creditAmount, int index) { // check to make sure that the if (!validateCreditAndDebitAmounts(debitAmount, creditAmount, index)) { return false; } // check to see which amount field has a value - credit or debit field? // and set the values of the appropriate fields if (debitAmount != null && debitAmount.isNonZero()) { // a value entered into the debit field? if so it's a debit // create a new instance w/out reference KualiDecimal tmpDebitAmount = new KualiDecimal(debitAmount.toString()); sourceLine.setDebitCreditCode(KFSConstants.GL_DEBIT_CODE); sourceLine.setAmount(tmpDebitAmount); } else if (creditAmount != null && creditAmount.isNonZero()) { // assume credit, if both are set the br eval framework will // catch it KualiDecimal tmpCreditAmount = new KualiDecimal(creditAmount.toString()); sourceLine.setDebitCreditCode(KFSConstants.GL_CREDIT_CODE); sourceLine.setAmount(tmpCreditAmount); } else { // default to DEBIT, note the br eval framework will still pick it up sourceLine.setDebitCreditCode(KFSConstants.GL_DEBIT_CODE); sourceLine.setAmount(KualiDecimal.ZERO); } return true; } /** * This method checks to make sure that there isn't a value in both the credit and debit columns for a given accounting line. * * @param creditAmount * @param debitAmount * @param index if -1, it's a new line, if not -1, then its an existing line * @return boolean False if both the credit and debit fields have a value, true otherwise. */ protected boolean validateCreditAndDebitAmounts(KualiDecimal debitAmount, KualiDecimal creditAmount, int index) { boolean valid = false; if (null != creditAmount && null != debitAmount) { if (creditAmount.isNonZero() && debitAmount.isNonZero()) { // there's a value in both fields if (KFSConstants.NEGATIVE_ONE == index) { // it's a new line GlobalVariables.getMessageMap().putErrorWithoutFullErrorPath( KFSConstants.DEBIT_AMOUNT_PROPERTY_NAME, KFSKeyConstants.ERROR_DOCUMENT_JV_AMOUNTS_IN_CREDIT_AND_DEBIT_FIELDS); GlobalVariables.getMessageMap().putErrorWithoutFullErrorPath( KFSConstants.CREDIT_AMOUNT_PROPERTY_NAME, KFSKeyConstants.ERROR_DOCUMENT_JV_AMOUNTS_IN_CREDIT_AND_DEBIT_FIELDS); } else { String errorKeyPath = KFSConstants.JOURNAL_LINE_HELPER_PROPERTY_NAME + KFSConstants.SQUARE_BRACKET_LEFT + Integer.toString(index) + KFSConstants.SQUARE_BRACKET_RIGHT; GlobalVariables.getMessageMap().putErrorWithoutFullErrorPath( errorKeyPath + VOUCHER_LINE_HELPER_DEBIT_PROPERTY_NAME, KFSKeyConstants.ERROR_DOCUMENT_JV_AMOUNTS_IN_CREDIT_AND_DEBIT_FIELDS); GlobalVariables.getMessageMap().putErrorWithoutFullErrorPath( errorKeyPath + VOUCHER_LINE_HELPER_CREDIT_PROPERTY_NAME, KFSKeyConstants.ERROR_DOCUMENT_JV_AMOUNTS_IN_CREDIT_AND_DEBIT_FIELDS); } } else { valid = true; } } else { valid = true; } return valid; } }