/** 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);
}
/**
* 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);
}
