Example #1
0
  /** 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});
  }
Example #2
0
  /**
   * 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);
  }
Example #3
0
  /**
   * 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);
    }
  }
Example #4
0
  /** 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);
  }