@Test
  public void testGroupKeyCodeSetExtraction() {
    PayTypeBo pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "1"));
    Set<String> extractedGroupKeyCodeWithIdSet = pstnRptGrpBo.getGroupKeyCodeSet();
    Assert.assertEquals(extractedGroupKeyCodeWithIdSet.size(), 2);
    Assert.assertTrue(extractedGroupKeyCodeWithIdSet.contains("ISU-IA"));
    Assert.assertTrue(extractedGroupKeyCodeWithIdSet.contains("UGA-GA"));

    pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "5"));
    extractedGroupKeyCodeWithIdSet = pstnRptGrpBo.getGroupKeyCodeSet();
    Assert.assertEquals(2, extractedGroupKeyCodeWithIdSet.size());
    Assert.assertTrue(extractedGroupKeyCodeWithIdSet.contains("IU-IN"));
    Assert.assertTrue(extractedGroupKeyCodeWithIdSet.contains("UGA-GA"));

    pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "2"));
    extractedGroupKeyCodeWithIdSet = pstnRptGrpBo.getGroupKeyCodeSet();
    Assert.assertTrue(
        (extractedGroupKeyCodeWithIdSet == null) || extractedGroupKeyCodeWithIdSet.isEmpty());
    pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "4"));
    extractedGroupKeyCodeWithIdSet = pstnRptGrpBo.getGroupKeyCodeSet();
    Assert.assertTrue(
        (extractedGroupKeyCodeWithIdSet == null) || extractedGroupKeyCodeWithIdSet.isEmpty());
  }
  /**
   * Checks if there is another active security reporting group in the database with the same order
   * number
   *
   * @param reportingGroup the reporting group to validate
   * @return true if there is no othersecurity reporting group in the database with the same order
   *     number, false otherwise
   */
  public boolean validateReportingGroupOrder(SecurityReportingGroup reportingGroup) {
    boolean success = true;
    BusinessObjectService businessObjectService =
        SpringContext.getBean(BusinessObjectService.class);

    // get all the active security reporting groups in the database
    Map<String, String> fieldValues = new HashMap<String, String>();
    fieldValues.put(
        EndowPropertyConstants.SECURITY_REPORTING_GROUP_ACTIVE_INFICATOR, Boolean.TRUE.toString());
    fieldValues.put(
        EndowPropertyConstants.SECURITY_REPORTING_GROUP_ORDER,
        String.valueOf(reportingGroup.getSecurityReportingGrpOrder()));

    List<SecurityReportingGroup> dataToValidateList =
        new ArrayList<SecurityReportingGroup>(
            businessObjectService.findMatching(SecurityReportingGroup.class, fieldValues));

    // iterate throught the retrieved list of reporting groups and check if there is another
    // reporting group with the same order
    // number
    for (SecurityReportingGroup record : dataToValidateList) {
      if (reportingGroup.getCode() != null && !reportingGroup.getCode().equals(record.getCode())) {
        putFieldError(
            EndowPropertyConstants.SECURITY_REPORTING_GROUP_ORDER,
            EndowKeyConstants.SecurityReportingGroupConstants
                .ERROR_SECURITY_REPORTING_GROUP_ORDER_DUPLICATE_VALUE);
        success = false;
        break;
      }
    }
    return success;
  }
  /*
   * This method will set the values to award amount info xml object
   * attributes.
   */
  private AwardAmountInfo getAwardAmountInfo(Award award) {
    AmountInfoType amountInfoType = null;
    AwardAmountInfo awardAmountInfo = AwardAmountInfo.Factory.newInstance();
    List<AmountInfoType> amountInfoTypes = new ArrayList<AmountInfoType>();
    AwardHierarchy branchNode =
        award.getAwardHierarchyService().loadFullHierarchyFromAnyNode(award.getParentNumber());
    org.kuali.kra.award.home.AwardAmountInfo awardAmount = award.getLastAwardAmountInfo();
    BusinessObjectService businessObjectService =
        KraServiceLocator.getService(BusinessObjectService.class);
    Collection<Award> awards = businessObjectService.findAll(Award.class);
    Award parentAward = null;
    for (Award awardParent : awards) {
      if (awardParent.getAwardNumber().equals(branchNode.getAwardNumber())) {
        parentAward = awardParent;
        break;
      }
    }
    if (branchNode != null) {

      amountInfoType = setAwardAmountInfo(parentAward, parentAward.getLastAwardAmountInfo());
      amountInfoTypes = recurseTree(branchNode, amountInfoTypes);
      amountInfoTypes.add(0, amountInfoType);
      awardAmountInfo.setAmountInfoArray(amountInfoTypes.toArray(new AmountInfoType[0]));
    }
    return awardAmountInfo;
  }
  /**
   * @org
   *     .kuali.kfs.module.endow.document.service.CurrentTaxLotService#getCurrentTaxLotBalancesForMatchingSecurityClassCode(String)
   */
  public Collection<CurrentTaxLotBalance> getCurrentTaxLotBalancesForMatchingSecurityClassCode(
      String securityClassCode) {
    Collection<CurrentTaxLotBalance> currentTaxLotBalances = new ArrayList();

    Collection<Security> securities = new ArrayList();

    if (StringUtils.isNotBlank(securityClassCode)) {
      Map criteria = new HashMap();

      if (dataDictionaryService.getAttributeForceUppercase(
          Security.class, EndowPropertyConstants.SECURITY_CLASS_CODE)) {
        securityClassCode = securityClassCode.toUpperCase();
      }
      criteria.put(EndowPropertyConstants.SECURITY_CLASS_CODE, securityClassCode);

      securities = businessObjectService.findMatching(Security.class, criteria);

      for (Security security : securities) {
        criteria.clear();
        criteria.put(EndowPropertyConstants.CURRENT_TAX_LOT_BALANCE_SECURITY_ID, security.getId());

        currentTaxLotBalances.addAll(
            businessObjectService.findMatching(HoldingHistory.class, criteria));
      }
    }

    return currentTaxLotBalances;
  }
  @Override
  public ActionForward reload(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {
    BudgetForm budgetForm = (BudgetForm) form;
    // setBudgetPersonDefaultPeriodTypeCode(budgetForm);
    ActionForward actionForward = super.reload(mapping, form, request, response);
    BusinessObjectService bos = KraServiceLocator.getService(BusinessObjectService.class);
    BudgetDocument budgetDocument = budgetForm.getBudgetDocument();
    Budget budget = budgetDocument.getBudget();
    Map queryMap = new HashMap();
    queryMap.put("budgetId", budget.getBudgetId());
    Collection budgetPersons = bos.findMatching(BudgetPerson.class, queryMap);
    budget.setBudgetPersons(budgetPersons == null ? new ArrayList() : (List) budgetPersons);

    BudgetCategoryTypeValuesFinder budgetCategoryTypeValuesFinder =
        new BudgetCategoryTypeValuesFinder();
    List<KeyValue> budgetCategoryTypes = new ArrayList<KeyValue>();
    budgetCategoryTypes = budgetCategoryTypeValuesFinder.getKeyValues();
    for (int i = 0; i < budgetCategoryTypes.size(); i++) {
      budgetForm.getNewBudgetLineItems().add(budget.getNewBudgetLineItem());
    }
    budget.setBudgetCategoryTypeCodes(budgetCategoryTypes);

    return actionForward;
  }
  /**
   * This overridden updates an existing Rule in the Repository
   *
   * @see
   *     org.kuali.rice.krms.impl.repository.RuleBoService#updateRule(org.kuali.rice.krms.api.repository.rule.RuleDefinition)
   */
  @Override
  public void updateRule(RuleDefinition rule) {
    if (rule == null) {
      throw new IllegalArgumentException("rule is null");
    }

    // must already exist to be able to update
    final String ruleIdKey = rule.getId();
    final RuleBo existing = businessObjectService.findBySinglePrimaryKey(RuleBo.class, ruleIdKey);
    if (existing == null) {
      throw new IllegalStateException("the rule does not exist: " + rule);
    }
    final RuleDefinition toUpdate;
    if (!existing.getId().equals(rule.getId())) {
      // if passed in id does not match existing id, correct it
      final RuleDefinition.Builder builder = RuleDefinition.Builder.create(rule);
      builder.setId(existing.getId());
      toUpdate = builder.build();
    } else {
      toUpdate = rule;
    }

    // copy all updateable fields to bo
    RuleBo boToUpdate = RuleBo.from(toUpdate);

    // delete any old, existing attributes
    Map<String, String> fields = new HashMap<String, String>(1);
    fields.put(PropertyNames.Rule.RULE_ID, toUpdate.getId());
    businessObjectService.deleteMatching(RuleAttributeBo.class, fields);

    // update the rule and create new attributes
    businessObjectService.save(boToUpdate);
  }
  /**
   * @see
   *     org.kuali.kfs.module.endow.document.service.CurrentTaxLotService#clearAllCurrentTaxLotRecords()
   *     clears all the records from the CurrentTaxLotBalance table.
   */
  public void clearAllCurrentTaxLotRecords() {
    Collection<CurrentTaxLotBalance> currentTaxLotBalances =
        businessObjectService.findAll(CurrentTaxLotBalance.class);

    for (CurrentTaxLotBalance currentTaxLotBalance : currentTaxLotBalances) {
      businessObjectService.delete(currentTaxLotBalance);
    }
  }
  /**
   * @see org.kuali.kfs.module.endow.batch.service.AvailableCashUpdateService#clearAvailableCash()
   *     Method to clear all the records in the kemidCurrentAvailableBalance table
   */
  public void clearAllAvailableCash() {
    LOG.info("Step1: Clearing all available cash records");

    Collection<KEMIDCurrentAvailableBalance> KEMIDCurrentAvailableBalances =
        businessObjectService.findAll(KEMIDCurrentAvailableBalance.class);

    for (KEMIDCurrentAvailableBalance kemidCurrentAvailableBalance :
        KEMIDCurrentAvailableBalances) {
      businessObjectService.delete(kemidCurrentAvailableBalance);
    }
  }
 private String getRoleDescription(AwardUnitContact newUnitContact) {
   String roleDescription = "";
   BusinessObjectService boService = KcServiceLocator.getService(BusinessObjectService.class);
   UnitAdministratorType aType =
       boService.findBySinglePrimaryKey(
           UnitAdministratorType.class, newUnitContact.getUnitAdministratorTypeCode());
   if (aType != null) {
     roleDescription = aType.getDescription();
   }
   return roleDescription;
 }
 /**
  * @see
  *     org.kuali.kfs.module.ar.document.service.CustomerInvoiceDocumentService#updateReportedDate(String)
  */
 @Override
 public void updateReportedDate(String docNumber) {
   HashMap<String, String> criteria = new HashMap<String, String>();
   criteria.put("documentNumber", docNumber);
   CustomerInvoiceDocument customerInvoiceDocument =
       businessObjectService.findByPrimaryKey(CustomerInvoiceDocument.class, criteria);
   Date reportedDate = dateTimeService.getCurrentSqlDate();
   if (ObjectUtils.isNotNull(customerInvoiceDocument)) {
     customerInvoiceDocument.setReportedDate(reportedDate);
     businessObjectService.save(customerInvoiceDocument);
   }
 }
Example #11
0
  @SuppressWarnings("deprecation")
  @ConfigureContext(shouldCommitTransactions = false)
  public void testOJBConfiguration() throws Exception {
    TemProfile profile = new TemProfile();
    Integer newProfileId =
        sas.getNextAvailableSequenceNumber(TemConstants.TEM_PROFILE_SEQ_NAME).intValue();
    profile.setProfileId(newProfileId);
    profile.getTemProfileAddress().setProfileId(newProfileId);
    profile.setCustomerNumber("555555555");
    profile.setPrincipalId("66666666");
    profile.setDateOfBirth(new Date(Date.parse("03/03/1975")));
    profile.setCitizenship("United States");
    profile.setDriversLicenseExpDate(new Date(Date.parse("03/03/2014")));
    profile.setDriversLicenseNumber("B43212345");
    profile.setUpdatedBy("jamey");
    profile.setLastUpdate(new Date(Date.parse("03/03/2011")));
    profile.setGender("M");
    profile.setNonResidentAlien(false);
    profile.setHomeDeptChartOfAccountsCode("UA");
    profile.setHomeDeptOrgCode("VPIT");

    List<TravelerType> travelerTypes =
        (List<TravelerType>)
            businessObjectService.findMatching(TravelerType.class, new HashMap<String, Object>());
    profile.setTravelerType(travelerTypes.get(0));
    profile.setTravelerTypeCode(profile.getTravelerType().getCode());

    businessObjectService.save(profile);

    Map<String, Object> values = new HashMap<String, Object>();
    values.put(TemPropertyConstants.TemProfileProperties.PROFILE_ID, profile.getProfileId());

    List<TemProfile> profileList =
        (List<TemProfile>) businessObjectService.findMatching(TemProfile.class, values);
    try {
      assertTrue(profile.getCustomerNumber().equals(profileList.get(0).getCustomerNumber()));
      assertTrue(profile.getPrincipalId().equals(profileList.get(0).getPrincipalId()));
      assertTrue(profile.getDateOfBirth().equals(profileList.get(0).getDateOfBirth()));
      assertTrue(profile.getCitizenship().equals(profileList.get(0).getCitizenship()));
      assertTrue(
          profile.getDriversLicenseExpDate().equals(profileList.get(0).getDriversLicenseExpDate()));
      assertTrue(
          profile.getDriversLicenseNumber().equals(profileList.get(0).getDriversLicenseNumber()));
      assertTrue(profile.getUpdatedBy().equals(profileList.get(0).getUpdatedBy()));
      assertTrue(profile.getLastUpdate().equals(profileList.get(0).getLastUpdate()));
      assertTrue(profile.getGender().equals(profileList.get(0).getGender()));
      assertTrue(profile.getNonResidentAlien().equals(profileList.get(0).getNonResidentAlien()));
      assertTrue(profile.getHomeDepartment().equals(profileList.get(0).getHomeDepartment()));
    } catch (Exception e) {
      assert (false);
    }
  }
Example #12
0
 /**
  * . This is the Setter Method for siteInvestigator
  *
  * @param siteInvestigator The siteInvestigator to set.
  */
 public void setSiteInvestigator(Integer siteInvestigator) {
   if (siteInvestigator != null) {
     BusinessObjectService businessObjectService =
         KraServiceLocator.getService(BusinessObjectService.class);
     this.rolodex =
         (NonOrganizationalRolodex)
             businessObjectService.findByPrimaryKey(
                 NonOrganizationalRolodex.class,
                 getIdentifierMap(ROLODEX_ID_FIELD_NAME, siteInvestigator));
     this.siteInvestigatorId = rolodex.getRolodexId().toString();
   }
   this.siteInvestigator = siteInvestigator;
 }
 /**
  * Returns true if exactly one instance of a given business object type exists in the Database;
  * false otherwise.
  *
  * @param boType
  * @param propertyName the name of the BO field to query
  * @param keyField the field to test against.
  * @return true if one object exists; false if no objects or more than one are found
  */
 private boolean existsUnique(
     Class<? extends BusinessObject> boType, String propertyName, String keyField) {
   if (keyField != null) {
     BusinessObjectService businessObjectService =
         KcServiceLocator.getService(BusinessObjectService.class);
     Map<String, String> fieldValues = new HashMap<String, String>();
     fieldValues.put(propertyName, keyField);
     if (businessObjectService.countMatching(boType, fieldValues) == 1) {
       return true;
     }
   }
   return false;
 }
  @Test
  public void testKeyCodeSetOwnerAssignment() {
    PayTypeBo pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "1"));
    for (PayTypeKeyBo keyBo : pstnRptGrpBo.getEffectiveKeySet()) {
      Assert.assertEquals(keyBo.getOwnerId(), "1");
    }

    pstnRptGrpBo =
        boService.findByPrimaryKey(PayTypeBo.class, Collections.singletonMap("hrPayTypeId", "5"));
    for (PayTypeKeyBo keyBo : pstnRptGrpBo.getEffectiveKeySet()) {
      Assert.assertEquals(keyBo.getOwnerId(), "5");
    }
  }
Example #15
0
 /**
  * . This is the Getter Method for siteinvestigator
  *
  * @return Returns the siteInvestigator.
  */
 public Integer getSiteInvestigator() {
   if (siteInvestigator != null) {
     BusinessObjectService businessObjectService =
         KraServiceLocator.getService(BusinessObjectService.class);
     this.rolodex =
         (Rolodex)
             businessObjectService.findByPrimaryKey(
                 Rolodex.class, getIdentifierMap(ROLODEX_ID_FIELD_NAME, siteInvestigator));
     this.siteInvestigatorId = rolodex.getRolodexId().toString();
   } else {
     this.rolodex = null;
   }
   return siteInvestigator;
 }
Example #16
0
  public int loadTransactionIntoOriginEntryTable(OriginEntryGroup group) {
    int numberOfInputData = Integer.valueOf(properties.getProperty("numOfData"));
    businessObjectService.save(group);

    int[] fieldLength = this.getFieldLength(fieldLengthList);
    List<LaborOriginEntry> originEntries =
        this.loadInputData(
            LaborOriginEntry.class, "data", numberOfInputData, keyFieldList, fieldLength);
    for (LaborOriginEntry entry : originEntries) {
      entry.setEntryGroupId(group.getId());
    }

    businessObjectService.save(originEntries);
    return originEntries.size();
  }
 @Override
 public <T> Collection<T> findMatchingOrderBy(
     Class<T> clazz, Map<String, ?> fieldValues, String sortField, boolean sortAscending) {
   return (Collection<T>)
       businessObjectService.findMatchingOrderBy(
           (Class<BusinessObject>) clazz, fieldValues, sortField, sortAscending);
 }
  /**
   * @see
   *     org.kuali.kfs.module.tem.batch.service.CreditCardDataImportService#importCreditCardDataFile(java.lang.String,
   *     org.kuali.kfs.sys.batch.BatchInputFileType)
   */
  @Override
  public boolean importCreditCardDataFile(String dataFileName, BatchInputFileType inputFileType) {

    try {
      FileInputStream fileContents = new FileInputStream(dataFileName);

      byte[] fileByteContent = IOUtils.toByteArray(fileContents);
      CreditCardImportData creditCardData =
          (CreditCardImportData) batchInputFileService.parse(inputFileType, fileByteContent);
      IOUtils.closeQuietly(fileContents);

      LOG.info("Credit Card Import - validating: " + dataFileName);
      List<CreditCardStagingData> validCreditCardList =
          validateCreditCardData(creditCardData, dataFileName);
      if (!validCreditCardList.isEmpty()) {
        businessObjectService.save(validCreditCardList);
      }
    } catch (Exception ex) {
      LOG.error("Failed to process the file : " + dataFileName, ex);
      moveErrorFile(dataFileName, creditCardDataFileErrorDirectory);
      return false;
    } finally {
      removeDoneFiles(dataFileName);
    }
    return true;
  }
  /**
   * @org.kuali.kfs.module.endow.document.service.CurrentTaxLotService#getAllCurrentTaxLotBalance()
   */
  public Collection<CurrentTaxLotBalance> getAllCurrentTaxLotBalance() {
    Collection<CurrentTaxLotBalance> currentTaxLotBalances = new ArrayList();

    currentTaxLotBalances = businessObjectService.findAll(CurrentTaxLotBalance.class);

    return currentTaxLotBalances;
  }
  /**
   * @see
   *     org.kuali.kfs.module.endow.document.service.CurrentTaxLotService#getByPrimaryKey(java.lang.String,
   *     java.lang.String, java.lang.String, int, java.lang.String)
   */
  public void updateCurrentTaxLotBalance(CurrentTaxLotBalance currentTaxLotBalance) {
    if (currentTaxLotBalance == null) {
      throw new IllegalArgumentException("invalid (null) currentTaxLotBalance");
    }

    businessObjectService.save(currentTaxLotBalance);
  }
  @Override
  public void setUp() throws Exception {
    super.setUp();

    String messageFileName =
        LaborTestDataPropertyConstants.TEST_DATA_PACKAGE_NAME + "/message.properties";
    String propertiesFileName =
        LaborTestDataPropertyConstants.TEST_DATA_PACKAGE_NAME
            + "/laborGLLedgerEntryPoster.properties";

    properties = TestDataPreparator.loadPropertiesFromClassPath(propertiesFileName);

    fieldNames = properties.getProperty("fieldNames");
    deliminator = properties.getProperty("deliminator");
    keyFieldList = Arrays.asList(StringUtils.split(fieldNames, deliminator));

    laborGLLedgerEntryPoster =
        SpringContext.getBean(PostTransaction.class, "laborGLLedgerEntryPoster");
    businessObjectService = SpringContext.getBean(BusinessObjectService.class);
    originEntryGroupService = SpringContext.getBean(LaborOriginEntryGroupService.class);
    laborGeneralLedgerEntryService = SpringContext.getBean(LaborGeneralLedgerEntryService.class);
    DateTimeService dateTimeService = SpringContext.getBean(DateTimeService.class);

    // TODO:- commented out
    // group1 = originEntryGroupService.createGroup(dateTimeService.getCurrentSqlDate(),
    // LABOR_MAIN_POSTER_VALID, false, false, false);
    today = dateTimeService.getCurrentDate();

    LaborGeneralLedgerEntry cleanup = new LaborGeneralLedgerEntry();
    ObjectUtil.populateBusinessObject(cleanup, properties, "dataCleanup", fieldNames, deliminator);
    fieldValues =
        ObjectUtil.buildPropertyMap(
            cleanup, Arrays.asList(StringUtils.split(fieldNames, deliminator)));
    businessObjectService.deleteMatching(LaborGeneralLedgerEntry.class, fieldValues);
  }
  /**
   * This method tests whether a Organization BO with a given organization name exists.
   *
   * @param organizationName
   * @return
   */
  private boolean validateOrganizationExists(String organizationName) {
    BusinessObjectService businessObjectService =
        KraServiceLocator.getService(BusinessObjectService.class);
    Map<String, String> fieldValues = new HashMap<String, String>();
    fieldValues.put("organizationName", organizationName);

    boolean isValid = true;
    if (businessObjectService.countMatching(Organization.class, fieldValues) != 1) {
      this.reportError(
          NEW_AWARD_APPROVED_SUBAWARD + ORGANIZATION_NAME,
          KeyConstants.ERROR_ORGANIZATION_NAME_IS_INVALID,
          new String[] {organizationName});
      return false;
    }
    return isValid;
  }
  /**
   * @see
   *     org.kuali.kfs.module.ar.document.service.AccountsReceivableTaxService#getPostalCodeForTaxation(org.kuali.kfs.module.ar.document.CustomerInvoiceDocument)
   */
  @Override
  public String getPostalCodeForTaxation(CustomerInvoiceDocument document) {

    String postalCode = null;
    String customerNumber = document.getAccountsReceivableDocumentHeader().getCustomerNumber();
    Integer shipToAddressIdentifier = document.getCustomerShipToAddressIdentifier();

    // if customer number or ship to address id isn't provided, go to org options
    if (ObjectUtils.isNotNull(shipToAddressIdentifier) && StringUtils.isNotEmpty(customerNumber)) {

      CustomerAddressService customerAddressService =
          SpringContext.getBean(CustomerAddressService.class);
      CustomerAddress customerShipToAddress =
          customerAddressService.getByPrimaryKey(customerNumber, shipToAddressIdentifier);
      if (ObjectUtils.isNotNull(customerShipToAddress)) {
        postalCode = customerShipToAddress.getCustomerZipCode();
      }
    } else {
      Map<String, String> criteria = new HashMap<String, String>();
      criteria.put("chartOfAccountsCode", document.getBillByChartOfAccountCode());
      criteria.put("organizationCode", document.getBilledByOrganizationCode());
      OrganizationOptions organizationOptions =
          (OrganizationOptions)
              businessObjectService.findByPrimaryKey(OrganizationOptions.class, criteria);

      if (ObjectUtils.isNotNull(organizationOptions)) {
        postalCode = organizationOptions.getOrganizationPostalZipCode();
      }
    }
    return postalCode;
  }
 @Override
 public List<SubAward> getLinkedSubAwards(Award award) {
   Map<String, Object> values = new HashMap<String, Object>();
   values.put("awardId", award.getAwardId());
   Collection<SubAwardFundingSource> subAwardFundingSources =
       businessObjectService.findMatching(SubAwardFundingSource.class, values);
   Set<String> subAwardSet = new TreeSet<String>();
   for (SubAwardFundingSource subAwardFundingSource : subAwardFundingSources) {
     subAwardSet.add(subAwardFundingSource.getSubAward().getSubAwardCode());
   }
   List<SubAward> subAwards = new ArrayList<SubAward>();
   for (String subAwardCode : subAwardSet) {
     VersionHistory activeVersion =
         getVersionHistoryService().findActiveVersion(SubAward.class, subAwardCode);
     if (activeVersion == null) {
       VersionHistory pendingVersion =
           getVersionHistoryService().findPendingVersion(SubAward.class, subAwardCode);
       if (pendingVersion != null) {
         subAwards.add((SubAward) pendingVersion.getSequenceOwner());
       }
     } else {
       subAwards.add((SubAward) activeVersion.getSequenceOwner());
     }
   }
   return subAwards;
 }
  protected void buildSubTree(
      String principalName, BudgetConstructionOrganizationReports bcOrgRpts, int curLevel) {

    curLevel++;
    BudgetConstructionPullup bcPullup = new BudgetConstructionPullup();
    bcPullup.setPrincipalId(principalName);
    bcPullup.setChartOfAccountsCode(bcOrgRpts.getChartOfAccountsCode());
    bcPullup.setOrganizationCode(bcOrgRpts.getOrganizationCode());
    bcPullup.setReportsToChartOfAccountsCode(bcOrgRpts.getReportsToChartOfAccountsCode());
    bcPullup.setReportsToOrganizationCode(bcOrgRpts.getReportsToOrganizationCode());
    bcPullup.setPullFlag(new Integer(0));
    businessObjectService.save(bcPullup);

    if (curLevel <= MAXLEVEL) {
      // getActiveChildOrgs does not return orgs that report to themselves
      List childOrgs =
          budgetConstructionOrganizationReportsService.getActiveChildOrgs(
              bcOrgRpts.getChartOfAccountsCode(), bcOrgRpts.getOrganizationCode());
      if (childOrgs.size() > 0) {
        for (Iterator iter = childOrgs.iterator(); iter.hasNext(); ) {
          BudgetConstructionOrganizationReports bcOrg =
              (BudgetConstructionOrganizationReports) iter.next();
          buildSubTree(principalName, bcOrg, curLevel);
        }
      }
    } else {
      LOG.warn(
          String.format(
              "\n%s/%s reports to organization more than maxlevel of %d",
              bcOrgRpts.getChartOfAccountsCode(), bcOrgRpts.getOrganizationCode(), MAXLEVEL));
    }
  }
  /**
   * @see
   *     org.kuali.kfs.module.ar.document.service.CustomerInvoiceDocumentService#getInvoicesByCustomerNumber(java.lang.String)
   */
  @Override
  public Collection<CustomerInvoiceDocument> getCustomerInvoiceDocumentsByCustomerNumber(
      String customerNumber) {

    Collection<CustomerInvoiceDocument> invoices = new ArrayList<CustomerInvoiceDocument>();

    Map<String, String> fieldValues = new HashMap<String, String>();
    fieldValues.put("customerNumber", customerNumber);

    Collection<AccountsReceivableDocumentHeader> documentHeaders =
        businessObjectService.findMatching(AccountsReceivableDocumentHeader.class, fieldValues);

    List<String> documentHeaderIds = new ArrayList<String>();
    for (AccountsReceivableDocumentHeader header : documentHeaders) {
      documentHeaderIds.add(header.getDocumentHeader().getDocumentNumber());
    }

    if (0 < documentHeaderIds.size()) {
      try {
        for (Document doc :
            documentService.getDocumentsByListOfDocumentHeaderIds(
                CustomerInvoiceDocument.class, documentHeaderIds)) {
          invoices.add((CustomerInvoiceDocument) doc);
        }
      } catch (WorkflowException e) {
        LOG.error("getCustomerInvoiceDocumentsByCustomerNumber " + customerNumber + " failed", e);
      }
    }
    return invoices;
  }
  /**
   * @see
   *     org.kuali.kfs.module.endow.batch.service.AvailableCashUpdateService#InsertAvailableCash(KemidCurrentCash)
   *     Method to clear all the records in the kemidCurrentAvailableBalance table
   */
  public void InsertAvailableCash(KEMIDCurrentAvailableBalance kemidCurrentAvailableBalance) {
    if (kemidCurrentAvailableBalance == null) {
      throw new IllegalArgumentException("invalid (null) kemidCurrentAvailableBalance");
    }

    businessObjectService.save(kemidCurrentAvailableBalance);
  }
  /**
   * @see
   *     org.kuali.kfs.module.ar.document.service.CustomerInvoiceDocumentService#getOriginalTotalAmountForCustomerInvoiceDocument(org.kuali.kfs.module.ar.document.CustomerInvoiceDocument)
   */
  @Override
  public KualiDecimal getOriginalTotalAmountForCustomerInvoiceDocument(
      CustomerInvoiceDocument customerInvoiceDocument) {
    LOG.info(
        "\n\n\n\t\t invoice: "
            + customerInvoiceDocument.getDocumentNumber()
            + "\n\t\t 111111111 HEADER TOTAL AMOUNT (should be null): "
            + customerInvoiceDocument
                .getFinancialSystemDocumentHeader()
                .getFinancialDocumentTotalAmount()
            + "\n\n");
    customerInvoiceDocument.getDocumentNumber();
    HashMap criteria = new HashMap();
    criteria.put(
        KFSPropertyConstants.DOCUMENT_NUMBER,
        customerInvoiceDocument.getDocumentHeader().getDocumentTemplateNumber());
    FinancialSystemDocumentHeader financialSystemDocumentHeader =
        businessObjectService.findByPrimaryKey(FinancialSystemDocumentHeader.class, criteria);
    KualiDecimal originalTotalAmount = KualiDecimal.ZERO;
    originalTotalAmount = financialSystemDocumentHeader.getFinancialDocumentTotalAmount();

    LOG.info(
        "\n\n\n\t\t invoice: "
            + customerInvoiceDocument.getDocumentNumber()
            + "\n\t\t 333333333333 HEADER TOTAL AMOUNT (should be set now): "
            + customerInvoiceDocument
                .getFinancialSystemDocumentHeader()
                .getFinancialDocumentTotalAmount()
            + "\n\n");
    return originalTotalAmount;
  }
  /**
   * This method looks up the default table
   *
   * @param String unitNumber
   * @return AccountAutoCreateDefaults
   */
  protected AccountAutoCreateDefaults getAccountDefaults(String unitNumber) {

    AccountAutoCreateDefaults defaults = null;

    if (unitNumber == null || unitNumber.isEmpty()) {
      return null;
    }

    Map<String, String> criteria = new HashMap<String, String>();
    criteria.put("kcUnit", unitNumber);
    defaults = businessObjectService.findByPrimaryKey(AccountAutoCreateDefaults.class, criteria);

    // if the matching defaults is null, try the parents in the hierarchy
    if (defaults == null) {

      List<String> parentUnits = null;
      try {
        parentUnits =
            SpringContext.getBean(ContractsAndGrantsModuleService.class).getParentUnits(unitNumber);
      } catch (Exception ex) {
        LOG.error(
            KcUtils.getErrorMessage(
                    KcConstants.AccountCreationService.ERROR_KC_ACCOUNT_PARAMS_UNIT_NOTFOUND, null)
                + ": "
                + ex.getMessage());

        GlobalVariables.getMessageMap()
            .putError(
                KcConstants.AccountCreationService.ERROR_KC_ACCOUNT_PARAMS_UNIT_NOTFOUND,
                "kcUnit",
                ex.getMessage());
      }

      if (parentUnits != null) {
        for (String unit : parentUnits) {
          criteria.put("kcUnit", unit);
          defaults =
              businessObjectService.findByPrimaryKey(AccountAutoCreateDefaults.class, criteria);
          if (defaults != null) {
            break;
          }
        }
      }
    }

    return defaults;
  }
  public static List<KeyValue> initProfileDetailsForBatchDelete() {

    List<KeyValue> keyValues = new ArrayList<KeyValue>();
    BusinessObjectService businessObjectService = KRADServiceLocator.getBusinessObjectService();
    Map parentCriteria1 = new HashMap();
    parentCriteria1.put("batchProcessProfileType", "Batch Delete");
    List<OLEBatchProcessProfileBo> oleBatchProcessProfileBo =
        (List<OLEBatchProcessProfileBo>)
            businessObjectService.findMatching(OLEBatchProcessProfileBo.class, parentCriteria1);
    keyValues.add(new ConcreteKeyValue("", ""));
    for (OLEBatchProcessProfileBo profileBo : oleBatchProcessProfileBo) {
      keyValues.add(
          new ConcreteKeyValue(
              profileBo.getBatchProcessProfileName(), profileBo.getBatchProcessProfileId()));
    }
    return keyValues;
  }