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