/** This method changes account to suspenseAccount */ protected Message useSuspenseAccount(LaborOriginEntry workingEntry) { String suspenseAccountNumber = parameterService.getParameterValueAsString( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_ACCOUNT); String suspenseCOAcode = parameterService.getParameterValueAsString( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_CHART); String suspenseSubAccountNumber = parameterService.getParameterValueAsString( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_SUB_ACCOUNT); Account account = accountService.getByPrimaryId(suspenseCOAcode, suspenseAccountNumber); if (ObjectUtils.isNull(account)) { return MessageBuilder.buildMessage( LaborKeyConstants.ERROR_INVALID_SUSPENSE_ACCOUNT, Message.TYPE_FATAL); } workingEntry.setAccount(account); workingEntry.setAccountNumber(suspenseAccountNumber); workingEntry.setChartOfAccountsCode(suspenseCOAcode); workingEntry.setSubAccountNumber(suspenseSubAccountNumber); return MessageBuilder.buildMessageWithPlaceHolder( LaborKeyConstants.MESSAGE_SUSPENSE_ACCOUNT_APPLIED, Message.TYPE_WARNING, new Object[] {suspenseCOAcode, suspenseAccountNumber, suspenseSubAccountNumber}); }
/** * For fringe transaction types checks if the account accepts fringe benefits. If not, retrieves * the alternative account, then calls expiration checking on either the alternative account or * the account passed in. */ protected Message checkAccountFringeIndicator( LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, Account account, UniversityDate universityRunDate, LaborAccountingCycleCachingService laborAccountingCycleCachingService) { // check for fringe tranaction type // LaborObject laborObject = (LaborObject) // businessObjectService.findByPrimaryKey(LaborObject.class, fieldValues); LaborObject laborObject = laborAccountingCycleCachingService.getLaborObject( laborOriginEntry.getUniversityFiscalYear(), laborOriginEntry.getChartOfAccountsCode(), laborOriginEntry.getFinancialObjectCode()); boolean isFringeTransaction = laborObject != null && org.apache.commons.lang.StringUtils.equals( LaborConstants.BenefitExpenseTransfer.LABOR_LEDGER_BENEFIT_CODE, laborObject.getFinancialObjectFringeOrSalaryCode()); // alternative account handling for non fringe accounts if (isFringeTransaction && !account.isAccountsFringesBnftIndicator()) { Account altAccount = accountService.getByPrimaryId( laborOriginEntry.getAccount().getReportsToChartOfAccountsCode(), laborOriginEntry.getAccount().getReportsToAccountNumber()); if (ObjectUtils.isNotNull(altAccount)) { laborWorkingEntry.setAccount(altAccount); laborWorkingEntry.setAccountNumber(altAccount.getAccountNumber()); laborWorkingEntry.setChartOfAccountsCode(altAccount.getChartOfAccountsCode()); Message err = handleExpiredClosedAccount( altAccount, laborOriginEntry, laborWorkingEntry, universityRunDate); if (err == null) { err = MessageBuilder.buildMessageWithPlaceHolder( LaborKeyConstants.MESSAGE_FRINGES_MOVED_TO, Message.TYPE_WARNING, new Object[] {altAccount.getAccountNumber()}); } return err; } // no alt acct, use suspense acct if active boolean suspenseAccountLogicInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_ACCOUNT_LOGIC_PARAMETER); if (suspenseAccountLogicInd) { return useSuspenseAccount(laborWorkingEntry); } return MessageBuilder.buildMessage( LaborKeyConstants.ERROR_NON_FRINGE_ACCOUNT_ALTERNATIVE_NOT_FOUND, Message.TYPE_FATAL); } return handleExpiredClosedAccount( account, laborOriginEntry, laborWorkingEntry, universityRunDate); }
/** * determine if the given origin entry can be posted back to Labor GL entry * * @param originEntry the given origin entry, atransaction * @return a message list. The list has message(s) if the given origin entry cannot be posted back * to Labor GL entry; otherwise, it is empty */ protected List<Message> isPostableForLaborGLEntry(LaborOriginEntry originEntry) { List<Message> errors = new ArrayList<Message>(); MessageBuilder.addMessageIntoList( errors, TransactionFieldValidator.checkPostablePeridCode( originEntry, getPeriodCodesNotProcessed())); MessageBuilder.addMessageIntoList( errors, TransactionFieldValidator.checkPostableBalanceTypeCode( originEntry, getBalanceTypesNotProcessed())); MessageBuilder.addMessageIntoList( errors, TransactionFieldValidator.checkZeroTotalAmount(originEntry)); return errors; }
/** This method is for validation of PayrollEndFiscalPeriodCode */ protected Message validatePayrollEndFiscalPeriodCode( LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, UniversityDate universityRunDate, LaborAccountingCycleCachingService laborAccountingCycleCachingService) { LOG.debug("validateUniversityFiscalPeriodCode() started"); AccountingPeriod accountingPeriod = null; Integer tempPayrollFiscalYear = 0; if (laborOriginEntry.getPayrollEndDateFiscalYear() == null) { tempPayrollFiscalYear = universityRunDate.getUniversityFiscalYear(); } else { tempPayrollFiscalYear = laborOriginEntry.getPayrollEndDateFiscalYear(); } if (!laborOriginEntry.getPayrollEndDateFiscalPeriodCode().equals("")) { accountingPeriod = laborAccountingCycleCachingService.getAccountingPeriod( tempPayrollFiscalYear, laborOriginEntry.getPayrollEndDateFiscalPeriodCode()); if (accountingPeriod == null) { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_PAYROLL_END_DATE_FISCAL_PERIOD, laborOriginEntry.getPayrollEndDateFiscalPeriodCode(), Message.TYPE_FATAL); } } return null; }
/** * Checks the continuation account system indicator. If on checks whether the account is expired * or closed, and if so calls the contination logic. */ protected Message handleExpiredClosedAccount( Account account, LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, UniversityDate universityRunDate) { List<String> continuationAccountBypassBalanceTypeCodes = balanceTypService.getContinuationAccountBypassBalanceTypeCodes( universityRunDate.getUniversityFiscalYear()); List<String> continuationAccountBypassOriginationCodes = new ArrayList<String>( parameterService.getParameterValuesAsString( LaborScrubberStep.class, LaborConstants.Scrubber.CONTINUATION_ACCOUNT_BYPASS_ORIGINATION_CODES)); List<String> continuationAccountBypassDocumentTypeCodes = new ArrayList<String>( parameterService.getParameterValuesAsString( LaborScrubberStep.class, LaborConstants.Scrubber.CONTINUATION_ACCOUNT_BYPASS_DOCUMENT_TYPE_CODES)); Calendar today = Calendar.getInstance(); today.setTime(universityRunDate.getUniversityDate()); long offsetAccountExpirationTime = getAdjustedAccountExpirationDate(account); boolean isAccountExpiredOrClosed = (account.getAccountExpirationDate() != null && isAccountExpired(account, universityRunDate)) || !account.isActive(); boolean continuationAccountLogicInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.CONTINUATION_ACCOUNT_LOGIC_PARAMETER); if (continuationAccountLogicInd && isAccountExpiredOrClosed) { // special checks for origination codes that have override ability boolean isOverrideOriginCode = continuationAccountBypassOriginationCodes.contains( laborOriginEntry.getFinancialSystemOriginationCode()); if (isOverrideOriginCode && !account.isActive()) { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_ORIGIN_CODE_CANNOT_HAVE_CLOSED_ACCOUNT, laborOriginEntry.getChartOfAccountsCode() + "-" + laborOriginEntry.getAccountNumber(), Message.TYPE_FATAL); } boolean canBypass = isOverrideOriginCode || continuationAccountBypassBalanceTypeCodes.contains( laborOriginEntry.getFinancialBalanceTypeCode()) || continuationAccountBypassDocumentTypeCodes.contains( laborOriginEntry.getFinancialDocumentTypeCode().trim()); if (account.isActive() && canBypass) { return null; } return continuationAccountLogic( account, laborOriginEntry, laborWorkingEntry, universityRunDate); } return null; }
/** This method is for validation of payrollEndFiscalYear */ protected Message validatePayrollEndFiscalYear( LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, UniversityDate universityRunDate, LaborAccountingCycleCachingService laborAccountingCycleCachingService) { LOG.debug("validatePayrollEndFiscalYear() started"); SystemOptions scrubbedEntryOption = null; if (laborOriginEntry.getPayrollEndDateFiscalYear() != null) { scrubbedEntryOption = laborAccountingCycleCachingService.getSystemOptions( laborOriginEntry.getPayrollEndDateFiscalYear()); if (scrubbedEntryOption == null) { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_PAYROLL_END_DATE_FISCAL_YEAR, "" + laborOriginEntry.getPayrollEndDateFiscalYear(), Message.TYPE_FATAL); } } return null; }
/** * Validates the sub account of the origin entry * * @param originEntry the origin entry being scrubbed * @param workingEntry the scrubbed version of the origin entry * @return a Message if an error was encountered, otherwise null */ protected Message validateSubAccount( LaborOriginEntry originEntry, LaborOriginEntry workingEntry, LaborAccountingCycleCachingService laborAccountingCycleCachingService) { LOG.debug("validateSubAccount() started"); // when continuationAccount used, the subAccountNumber should be changed to dashes and skip // validation subAccount process if (continuationAccountIndicator) { workingEntry.setSubAccountNumber(KFSConstants.getDashSubAccountNumber()); return null; } // If the sub account number is empty, set it to dashes. // Otherwise set the workingEntry sub account number to the // sub account number of the input origin entry. if (org.springframework.util.StringUtils.hasText(originEntry.getSubAccountNumber())) { // sub account IS specified if (!KFSConstants.getDashSubAccountNumber().equals(originEntry.getSubAccountNumber())) { SubAccount originEntrySubAccount = laborAccountingCycleCachingService.getSubAccount( originEntry.getChartOfAccountsCode(), originEntry.getAccountNumber(), originEntry.getSubAccountNumber()); // SubAccount originEntrySubAccount = getSubAccount(originEntry); if (originEntrySubAccount == null) { // sub account is not valid return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_SUB_ACCOUNT_NOT_FOUND, originEntry.getChartOfAccountsCode() + "-" + originEntry.getAccountNumber() + "-" + originEntry.getSubAccountNumber(), Message.TYPE_FATAL); } else { // sub account IS valid if (originEntrySubAccount.isActive()) { // sub account IS active workingEntry.setSubAccountNumber(originEntry.getSubAccountNumber()); } else { // sub account IS NOT active if (parameterService .getParameterValueAsString( KfsParameterConstants.GENERAL_LEDGER_BATCH.class, KFSConstants.SystemGroupParameterNames.GL_ANNUAL_CLOSING_DOC_TYPE) .equals(originEntry.getFinancialDocumentTypeCode())) { // document IS annual closing workingEntry.setSubAccountNumber(originEntry.getSubAccountNumber()); } else { // document is NOT annual closing return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_SUB_ACCOUNT_NOT_ACTIVE, originEntry.getChartOfAccountsCode() + "-" + originEntry.getAccountNumber() + "-" + originEntry.getSubAccountNumber(), Message.TYPE_FATAL); } } } } else { // the sub account is dashes workingEntry.setSubAccountNumber(KFSConstants.getDashSubAccountNumber()); } } else { // No sub account is specified. workingEntry.setSubAccountNumber(KFSConstants.getDashSubAccountNumber()); } return null; }
/** * Loops through continuation accounts for 10 tries or until it finds an account that is not * expired. */ protected Message continuationAccountLogic( Account expiredClosedAccount, LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, UniversityDate universityRunDate) { String chartCode = expiredClosedAccount.getContinuationFinChrtOfAcctCd(); String accountNumber = expiredClosedAccount.getContinuationAccountNumber(); List<String> checkedAccountNumbers = new ArrayList<String>(); for (int i = 0; i < 10; ++i) { if (checkedAccountNumbers.contains(chartCode + accountNumber)) { // Something is really wrong with the data because this account has already been evaluated. return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_CIRCULAR_DEPENDENCY_IN_CONTINUATION_ACCOUNT_LOGIC, Message.TYPE_FATAL); } checkedAccountNumbers.add(chartCode + accountNumber); if (chartCode == null || accountNumber == null) { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_CONTINUATION_ACCOUNT_NOT_FOUND, Message.TYPE_FATAL); } // Lookup the account Account account = accountService.getByPrimaryId(chartCode, accountNumber); if (ObjectUtils.isNull(account)) { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_CONTINUATION_ACCOUNT_NOT_FOUND, Message.TYPE_FATAL); } // check account expiration long offsetAccountExpirationTime = getAdjustedAccountExpirationDate(account); if (ObjectUtils.isNotNull(account.getAccountExpirationDate()) && isAccountExpired(account, universityRunDate)) { chartCode = account.getContinuationFinChrtOfAcctCd(); accountNumber = account.getContinuationAccountNumber(); } else { // set continuationAccountLogicIndi continuationAccountIndicator = true; laborWorkingEntry.setAccount(account); laborWorkingEntry.setAccountNumber(accountNumber); laborWorkingEntry.setChartOfAccountsCode(chartCode); laborWorkingEntry.setSubAccountNumber(KFSConstants.getDashSubAccountNumber()); laborWorkingEntry.setTransactionLedgerEntryDescription( kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.MSG_AUTO_FORWARD) + " " + expiredClosedAccount.getChartOfAccountsCode() + expiredClosedAccount.getAccountNumber() + laborOriginEntry.getTransactionLedgerEntryDescription()); return MessageBuilder.buildMessage( KFSKeyConstants.MSG_ACCOUNT_CLOSED_TO, laborWorkingEntry.getChartOfAccountsCode() + "-" + laborWorkingEntry.getAccountNumber(), Message.TYPE_WARNING); } } // We failed to find a valid continuation account. boolean suspenseAccountLogicInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_ACCOUNT_LOGIC_PARAMETER); if (suspenseAccountLogicInd) { return useSuspenseAccount(laborWorkingEntry); } else { return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_CONTINUATION_ACCOUNT_LIMIT_REACHED, Message.TYPE_FATAL); } }
/** Performs Account Validation. */ protected Message validateAccount( LaborOriginEntry laborOriginEntry, LaborOriginEntry laborWorkingEntry, UniversityDate universityRunDate, LaborAccountingCycleCachingService laborAccountingCycleCachingService) { LOG.debug("validateAccount() started"); Account account = laborOriginEntry.getAccount(); boolean suspenseAccountLogicInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.SUSPENSE_ACCOUNT_LOGIC_PARAMETER); if (ObjectUtils.isNull(account)) { if (suspenseAccountLogicInd) { return useSuspenseAccount(laborWorkingEntry); } return MessageBuilder.buildMessage( KFSKeyConstants.ERROR_ACCOUNT_NOT_FOUND, laborOriginEntry.getChartOfAccountsCode() + "-" + laborOriginEntry.getAccountNumber(), Message.TYPE_FATAL); } // default laborWorkingEntry.setAccount(account); laborWorkingEntry.setChartOfAccountsCode(account.getChartOfAccountsCode()); laborWorkingEntry.setAccountNumber(account.getAccountNumber()); // no further validation for gl annual doc type String glAnnualClosingType = parameterService.getParameterValueAsString( KfsParameterConstants.GENERAL_LEDGER_BATCH.class, KFSConstants.SystemGroupParameterNames.GL_ANNUAL_CLOSING_DOC_TYPE); if (glAnnualClosingType.equals(laborOriginEntry.getFinancialDocumentTypeCode())) { return null; } // Sub-Fund Wage Exclusion String orginationCode = laborOriginEntry.getFinancialSystemOriginationCode(); List<String> nonWageSubfundBypassOriginationCodes = new ArrayList<String>( parameterService.getParameterValuesAsString( LaborScrubberStep.class, LaborConstants.Scrubber.NON_WAGE_SUB_FUND_BYPASS_ORIGINATIONS)); boolean subfundWageExclusionInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.SUBFUND_WAGE_EXCLUSION_PARAMETER); if (subfundWageExclusionInd && !account.getSubFundGroup().isSubFundGroupWagesIndicator() && !nonWageSubfundBypassOriginationCodes.contains(orginationCode)) { if (suspenseAccountLogicInd) { return useSuspenseAccount(laborWorkingEntry); } return MessageBuilder.buildMessage( LaborKeyConstants.ERROR_SUN_FUND_NOT_ACCEPT_WAGES, Message.TYPE_FATAL); } // Account Fringe Validation List<String> nonFringeAccountBypassOriginationCodes = new ArrayList<String>( parameterService.getParameterValuesAsString( LaborScrubberStep.class, LaborConstants.Scrubber.NON_FRINGE_ACCOUNT_BYPASS_ORIGINATIONS)); boolean accountFringeExclusionInd = parameterService.getParameterValueAsBoolean( LaborScrubberStep.class, LaborConstants.Scrubber.ACCOUNT_FRINGE_EXCLUSION_PARAMETER); if (accountFringeExclusionInd && !nonFringeAccountBypassOriginationCodes.contains(orginationCode)) { return checkAccountFringeIndicator( laborOriginEntry, laborWorkingEntry, account, universityRunDate, laborAccountingCycleCachingService); } // Expired/Closed Validation return handleExpiredClosedAccount( laborOriginEntry.getAccount(), laborOriginEntry, laborWorkingEntry, universityRunDate); }