/*
   * check if custom attribute id is valid
   */
  private boolean checkCustomAttributeExist(MaintenanceDocument maintenanceDocument) {

    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "new maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
    }
    CustomAttributeDocument newCustomAttributeDocument =
        (CustomAttributeDocument) maintenanceDocument.getNewMaintainableObject().getDataObject();

    if (newCustomAttributeDocument.getCustomAttributeId() != null) {
      Map<String, String> queryMap = new HashMap<String, String>();
      queryMap.put("id", newCustomAttributeDocument.getCustomAttributeId().toString());

      if (getBoService().countMatching(CustomAttribute.class, queryMap) == 0) {
        GlobalVariables.getMessageMap()
            .putError(
                Constants.DOCUMENT_NEWMAINTAINABLEOBJECT_CUSTOM_ATTRIBUTE_ID,
                KeyConstants.ERROR_INVALID_CUSTOM_ATT_ID,
                new String[] {newCustomAttributeDocument.getCustomAttributeId().toString()});
        return false;
      }
    }

    return true;
  }
  /**
   * This method will create a maintenance document for CG account create, set its description and
   * then sets the account business object in it. The document will then be tried to route, save or
   * blanket approve automatically based on the system parameter. If successful, the method returns
   * the newly created document number to the caller.
   *
   * @return documentNumber returns the documentNumber
   * @see
   *     org.kuali.kfs.coa.document.service.CreateAccountService#createAutomaticCGAccountMaintenanceDocument()
   */
  protected void createAutomaticCGAccountMaintenanceDocument(
      Account account, AccountCreationStatusDTO accountCreationStatus) {

    // create a new maintenance document
    MaintenanceDocument maintenanceAccountDocument =
        (MaintenanceDocument) createCGAccountMaintenanceDocument(accountCreationStatus);

    if (ObjectUtils.isNotNull(maintenanceAccountDocument)) {
      // set document header description...
      maintenanceAccountDocument
          .getDocumentHeader()
          .setDocumentDescription(
              KcConstants.AccountCreationService
                  .AUTOMATCICG_ACCOUNT_MAINTENANCE_DOCUMENT_DESCRIPTION);

      // set the account object in the maintenance document.
      maintenanceAccountDocument.getNewMaintainableObject().setBusinessObject(account);
      maintenanceAccountDocument
          .getNewMaintainableObject()
          .setMaintenanceAction(KRADConstants.MAINTENANCE_NEW_ACTION);
      // the maintenance document will now be routed based on the system parameter value for
      // routing.
      createRouteAutomaticCGAccountDocument(maintenanceAccountDocument, accountCreationStatus);
    }
  }
  /**
   * This method is to check the existence of budgetcategorycode in table.
   *
   * @param maintenanceDocument
   * @return
   */
  private boolean checkExistence(MaintenanceDocument maintenanceDocument) {

    boolean valid = true;
    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "new maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
    }
    // shared by budgetcategorymapping & costelement
    // TODO : refactoring this - must have a better way to handle this sharing
    String budgetCategoryCode;
    if (maintenanceDocument.getNewMaintainableObject().getDataObject()
        instanceof BudgetCategoryMapping) {
      BudgetCategoryMapping budgetCategoryMapping =
          (BudgetCategoryMapping) maintenanceDocument.getNewMaintainableObject().getDataObject();
      budgetCategoryCode = budgetCategoryMapping.getBudgetCategoryCode();
    } else {
      CostElement costElement =
          (CostElement) maintenanceDocument.getNewMaintainableObject().getDataObject();
      budgetCategoryCode = costElement.getBudgetCategoryCode();
    }
    Map pkMap = new HashMap();
    pkMap.put("code", budgetCategoryCode);
    valid = checkExistenceFromTable(BudgetCategory.class, pkMap, "code", "Budget Category");

    return valid;
  }
  /**
   * This method to check whether 'lookupreturn' is specified if lookupclass is selected.
   *
   * @param maintenanceDocument
   * @return
   */
  private boolean checkLookupReturn(MaintenanceDocument maintenanceDocument) {
    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "New maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
    }
    ProposalColumnsToAlter newEditableProposalField =
        (ProposalColumnsToAlter) maintenanceDocument.getNewMaintainableObject().getDataObject();

    if (StringUtils.isNotBlank(newEditableProposalField.getLookupClass())) {
      GlobalVariables.getUserSession()
          .addObject(
              Constants.LOOKUP_CLASS_NAME, (Object) newEditableProposalField.getLookupClass());
    }
    if (StringUtils.isNotBlank(newEditableProposalField.getLookupClass())
        && StringUtils.isBlank(newEditableProposalField.getLookupReturn())) {
      GlobalVariables.getMessageMap()
          .putError(
              Constants.PROPOSAL_EDITABLECOLUMN_LOOKUPRETURN,
              RiceKeyConstants.ERROR_REQUIRED,
              new String[] {"Lookup Return"});
      return false;
    }

    return true;
  }
  /**
   * @see
   *     org.kuali.rice.kns.maintenance.KualiMaintainableImpl#processAfterEdit(org.kuali.rice.kns.document.MaintenanceDocument,
   *     java.util.Map)
   */
  @Override
  public void processAfterEdit(MaintenanceDocument document, Map<String, String[]> parameters) {
    List<ErrorMessage> errorMessages = null;
    AgencyStagingData agency =
        (AgencyStagingData) document.getNewMaintainableObject().getBusinessObject();

    if (TemConstants.ExpenseImportTypes.IMPORT_BY_TRIP.equals(agency.getImportBy())) {
      errorMessages = getExpenseImportByTripService().validateAgencyData(agency);
    } else if (TemConstants.ExpenseImportTypes.IMPORT_BY_TRAVELLER.equals(agency.getImportBy())) {
      errorMessages = getExpenseImportByTravelerService().validateAgencyData(agency);
    }

    if (errorMessages.isEmpty()) {
      agency.setErrorCode(AgencyStagingDataErrorCodes.AGENCY_NO_ERROR);
    }

    MessageMap messageMap = GlobalVariables.getMessageMap();
    for (ErrorMessage message : errorMessages) {
      messageMap.putError(
          KFSConstants.GLOBAL_ERRORS, message.getErrorKey(), message.getMessageParameters());
    }

    updateCreditCardAgency(
        (AgencyStagingData) document.getNewMaintainableObject().getBusinessObject());

    super.processAfterEdit(document, parameters);
  }
Example #6
0
  @SuppressWarnings("deprecation")
  public void testApplyGlobalChanges1() throws WorkflowException {

    MaintenanceDocument document;
    document =
        (MaintenanceDocument)
            SpringContext.getBean(DocumentService.class).getNewDocument(GLOBAL_DELEGATE_TYPENAME);
    document.getDocumentHeader().setDocumentDescription("blah");

    // get local references to the Maintainable and the BO
    Maintainable newMaintainable = document.getNewMaintainableObject();
    AccountDelegateGlobal bo = (AccountDelegateGlobal) newMaintainable.getBusinessObject();
    String finDocNumber = document.getDocumentHeader().getDocumentNumber();

    // create the lists
    List<AccountDelegateGlobalDetail> changeDocuments = new ArrayList();
    List<AccountGlobalDetail> accountDetails = new ArrayList();

    // add a delegate change document
    AccountDelegateGlobalDetail change = new AccountDelegateGlobalDetail();
    change.setDocumentNumber(finDocNumber);
    change.setAccountDelegatePrimaryRoutingIndicator(true);
    change.setAccountDelegateStartDate(START_DATE_1);
    change.setAccountDelegateUniversalId(DELEGATE_ID_1);
    change.setApprovalFromThisAmount(FROM_AMOUNT_1);
    change.setApprovalToThisAmount(TO_AMOUNT_1);
    change.setFinancialDocumentTypeCode(DOC_TYPE_ALL);
    changeDocuments.add(change);

    bo.setDelegateGlobals(changeDocuments);

    // add account change detail records
    AccountGlobalDetail account;
    account = new AccountGlobalDetail();
    account.setDocumentNumber(finDocNumber);
    account.setChartOfAccountsCode(COA1);
    account.setAccountNumber(ACCOUNT1);
    accountDetails.add(account);

    account = new AccountGlobalDetail();
    account.setDocumentNumber(finDocNumber);
    account.setChartOfAccountsCode(COA1);
    account.setAccountNumber(ACCOUNT2);
    accountDetails.add(account);

    account = new AccountGlobalDetail();
    account.setDocumentNumber(finDocNumber);
    account.setChartOfAccountsCode(COA1);
    account.setAccountNumber(ACCOUNT3);
    accountDetails.add(account);

    bo.setAccountGlobalDetails(accountDetails);

    GlobalBusinessObject gbo = (GlobalBusinessObject) bo;
    List<PersistableBusinessObject> persistables = gbo.generateGlobalChangesToPersist();

    assertFalse("The list should not be empty.", persistables.isEmpty());
    assertEquals("There should be three output records.", 3, persistables.size());
  }
  /**
   * This method to check whether it is ok to inactivate a custom attribute document.
   *
   * @param maintenanceDocument
   * @return
   */
  private boolean checkOkToInActivate(MaintenanceDocument maintenanceDocument) {

    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "new maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
    }
    CustomAttributeDocument newCustomAttributeDocument =
        (CustomAttributeDocument) maintenanceDocument.getNewMaintainableObject().getDataObject();

    return true;
  }
  /**
   * @see
   *     org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase#processCustomRouteDocumentBusinessRules(org.kuali.rice.kns.document.MaintenanceDocument)
   */
  public boolean processCustomRouteDocumentBusinessRules(MaintenanceDocument document) {
    final ValidAwardBasisPayment validAwardBasisPayment =
        (ValidAwardBasisPayment) document.getNewMaintainableObject().getDataObject();

    if (!document
        .getNewMaintainableObject()
        .getMaintenanceAction()
        .equals(KRADConstants.MAINTENANCE_DELETE_ACTION)) {
      return validateUniqueueCodes(
          validAwardBasisPayment.getAwardType(), validAwardBasisPayment.getBasisOfPayment());
    } else {
      return true;
    }
  }
  /**
   * Set value for newACIModel.
   *
   * @param document the newACIModel Maintenance document
   */
  private void setupConvenienceObjects(MaintenanceDocument document) {

    // setup newACIModel convenience objects, make sure all possible sub-objects are populated
    newACIModel =
        (AutomatedCashInvestmentModel) document.getNewMaintainableObject().getBusinessObject();
    newACIModel.refreshNonUpdateableReferences();
  }
  /**
   * Update Traveler information (name, id, network id) after looking up the Profile
   *
   * @param refreshCaller
   * @param fieldValues
   * @param document
   */
  protected void updateFieldsFromProfileRefresh(
      String refreshCaller, Map fieldValues, MaintenanceDocument document) {

    if (StringUtils.isNotEmpty(refreshCaller)
        && refreshCaller.equals(TemConstants.TEM_PROFILE_LOOKUPABLE)) {

      AgencyStagingDataMaintainable newMaintainable =
          (AgencyStagingDataMaintainable) document.getNewMaintainableObject();
      AgencyStagingData agencyData = (AgencyStagingData) newMaintainable.getBusinessObject();

      TemProfile profile = agencyData.getProfile();
      if (ObjectUtils.isNotNull(profile)) {
        if (StringUtils.isNotEmpty(profile.getEmployeeId())) {
          agencyData.setTravelerId(profile.getEmployeeId());
        } else if (StringUtils.isNotEmpty(profile.getCustomerNumber())) {
          agencyData.setTravelerId(profile.getCustomerNumber());
        } else {
          agencyData.setTravelerId("");
        }

        agencyData.setTravelerName(profile.getFirstName() + " " + profile.getLastName());

        if (ObjectUtils.isNotNull(profile.getPrincipal())) {
          agencyData.setTravelerNetworkId(profile.getPrincipal().getPrincipalName());
        } else {
          agencyData.setTravelerNetworkId("");
        }
      }
    }
  }
  private boolean checkUniqueness(MaintenanceDocument document) {
    boolean isValid = true;

    CoiNoteType newCoiNoteType = (CoiNoteType) document.getNewMaintainableObject().getDataObject();

    isValid &= checkSortIdUniqueness(newCoiNoteType);
    isValid &= checkDescriptionUniqueness(newCoiNoteType);

    return isValid;
  }
  /**
   * This method executes the DataDictionary Validation against the document. It's an exact replica
   * of MaintenanceDocumentRuleBase with the exception of the error path being
   * "document.newMaintainableObject.businessObject" instead of "document.newMaintainableObject".
   * TODO: Find a better solution as this duplicates code and is prone to failure if the rice
   * framework changes, specifically its dataDictionaryValidate method.
   *
   * @param document
   * @return true if it passes DD validation, false otherwise
   */
  @Override
  protected boolean dataDictionaryValidate(MaintenanceDocument document) {
    LOG.debug("MaintenanceDocument validation beginning");

    // explicitly put the errorPath that the dictionaryValidationService requires
    GlobalVariables.getMessageMap().addToErrorPath("document.newMaintainableObject.businessObject");

    // document must have a newMaintainable object
    Maintainable newMaintainable = document.getNewMaintainableObject();
    if (newMaintainable == null) {
      GlobalVariables.getMessageMap().removeFromErrorPath("document.newMaintainableObject");
      throw new ValidationException(
          "Maintainable object from Maintenance Document '"
              + document.getDocumentTitle()
              + "' is null, unable to proceed.");
    }

    // document's newMaintainable must contain an object (ie, not null)
    PersistableBusinessObject businessObject = newMaintainable.getBusinessObject();
    if (businessObject == null) {
      GlobalVariables.getMessageMap().removeFromErrorPath("document.newMaintainableObject.");
      throw new ValidationException("Maintainable's component business object is null.");
    }

    // run required check from maintenance data dictionary
    maintDocDictionaryService.validateMaintenanceRequiredFields(document);

    // check for duplicate entries in collections if necessary
    maintDocDictionaryService.validateMaintainableCollectionsForDuplicateEntries(document);

    // run the DD DictionaryValidation (non-recursive)
    dictionaryValidationService.validateBusinessObject(businessObject, false);

    // do default (ie, mandatory) existence checks
    dictionaryValidationService.validateDefaultExistenceChecks(businessObject);

    // explicitly remove the errorPath we've added
    GlobalVariables.getMessageMap()
        .removeFromErrorPath("document.newMaintainableObject.businessObject");

    LOG.debug("MaintenanceDocument validation ending");
    return true;
  }
  /**
   * This calls the {@link
   * OrganizationReversionPreRules#copyKeyAttributesToDetail(OrganizationReversion)}
   *
   * @see
   *     org.kuali.ole.coa.document.validation.impl.MaintenancePreRulesBase#doCustomPreRules(org.kuali.rice.kns.document.MaintenanceDocument)
   */
  @Override
  protected boolean doCustomPreRules(MaintenanceDocument document) {

    OrganizationReversion orgRev =
        (OrganizationReversion) document.getNewMaintainableObject().getBusinessObject();
    // copy year and chart to detail records
    copyKeyAttributesToDetail(orgRev);
    copyDefaultObjectcodeIfNoCarryForwardByObjectCode(orgRev);
    return true;
  }
 /**
  * Creates a KualiMaintenanceForm with the given rule template inside of its RuleBaseValues
  * instance.
  *
  * @param rtName The rule template to use.
  */
 private void createNewKualiMaintenanceForm(String rtName) {
   // Initialize the required variables.
   final KualiMaintenanceForm kmForm = new KualiMaintenanceForm();
   final MaintenanceDocument maintDoc = new MaintenanceDocumentBase();
   final Maintainable oldMaint = new RoutingRuleMaintainable();
   final Maintainable newMaint = new RoutingRuleMaintainable();
   final RuleBaseValues rbValues = new RuleBaseValues();
   // Setup the rule base and the maintainables.
   rbValues.setRuleTemplate(
       KEWServiceLocator.getRuleTemplateService().findByRuleTemplateName(rtName));
   oldMaint.setBusinessObject(rbValues);
   oldMaint.setBoClass(rbValues.getClass());
   newMaint.setBusinessObject(rbValues);
   newMaint.setBoClass(rbValues.getClass());
   // Setup the maintenance document and the maintenance form.
   maintDoc.setOldMaintainableObject(oldMaint);
   maintDoc.setNewMaintainableObject(newMaint);
   maintDoc.getDocumentHeader().setDocumentDescription("This is a rule template test");
   kmForm.setDocument(maintDoc);
   KNSGlobalVariables.setKualiForm(kmForm);
 }
 @SuppressWarnings("deprecation")
 private boolean isSignatureIdValid(MaintenanceDocument document) {
   boolean isValid = true;
   PersonSignatureModule personSignatureModule =
       (PersonSignatureModule) document.getNewMaintainableObject().getDataObject();
   Map<String, Long> keyMap = new HashMap<String, Long>();
   keyMap.put("personSignatureId", personSignatureModule.getPersonSignatureId());
   isValid =
       checkExistenceFromTable(
           PersonSignature.class, keyMap, "personSignatureId", "Person Signature Id");
   return isValid;
 }
  /**
   * This method validates the question status. The status can not be inactive when a questionnaire
   * is using the question.
   *
   * @param maintenanceDocument - the maintenance document of the question to be validated
   * @return true if all validation has passed, false otherwise
   */
  private boolean validateQuestionUsage(MaintenanceDocument maintenanceDocument) {
    Question question = (Question) maintenanceDocument.getNewMaintainableObject().getDataObject();

    if (!"A".equals(question.getStatus())
        && getQuestionService().isQuestionUsed(question.getQuestionId())) {
      GlobalVariables.getMessageMap()
          .putError(
              Constants.QUESTION_DOCUMENT_FIELD_STATUS, KeyConstants.ERROR_QUESTION_STATUS_IN_USE);
      return false;
    } else {
      return true;
    }
  }
  /**
   * @see
   *     org.kuali.rice.krad.document.authorization.MaintenanceDocumentPresentationControllerBase#getConditionallyReadOnlyPropertyNames(org.kuali.rice.kns.document.MaintenanceDocument)
   */
  @Override
  public Set<String> getConditionallyReadOnlyPropertyNames(MaintenanceDocument document) {

    Set<String> fields = super.getConditionallyReadOnlyPropertyNames(document);

    if (KRADConstants.MAINTENANCE_EDIT_ACTION.equals(
        document.getNewMaintainableObject().getMaintenanceAction())) {
      // a class code, once established as a certain class code type cannot change to a different
      // class code type
      fields.add(EndowPropertyConstants.CLASS_CODE_TYPE);
    }
    return fields;
  }
 @SuppressWarnings("deprecation")
 private boolean isNotDuplicateSignatureId(MaintenanceDocument document) {
   boolean isValid = true;
   PersonSignatureModule personSignatureModule =
       (PersonSignatureModule) document.getNewMaintainableObject().getDataObject();
   Map<String, Object> fieldValues = new HashMap<String, Object>();
   fieldValues.put("personSignatureId", personSignatureModule.getPersonSignatureId());
   fieldValues.put("moduleCode", personSignatureModule.getModuleCode());
   if (document.isNew()) {
     isValid = getBoService().countMatching(PersonSignatureModule.class, fieldValues) == 0;
   } else if (document.isEdit()) {
     isValid = isRecordUpdateValid(fieldValues, personSignatureModule);
   }
   if (!isValid) {
     ErrorReporter errorReporter = KcServiceLocator.getService(ErrorReporter.class);
     errorReporter.reportError(
         "document.newMaintainableObject.personSignatureId",
         PERSON_SIGNATURE_ID_INVALID_ERROR_KEY,
         new String[] {});
   }
   return isValid;
 }
Example #19
0
  public void testApplyGlobalChanges_Empty() throws WorkflowException {

    MaintenanceDocument document;
    document =
        (MaintenanceDocument)
            SpringContext.getBean(DocumentService.class).getNewDocument(GLOBAL_DELEGATE_TYPENAME);
    document.getDocumentHeader().setDocumentDescription("blah");

    // get local references to the Maintainable and the BO
    Maintainable newMaintainable = document.getNewMaintainableObject();
    AccountDelegateGlobal bo = (AccountDelegateGlobal) newMaintainable.getBusinessObject();

    List<AccountDelegateGlobalDetail> changeDocuments = new ArrayList();
    bo.setDelegateGlobals(changeDocuments);

    List<AccountGlobalDetail> accountDetails = new ArrayList();
    bo.setAccountGlobalDetails(accountDetails);

    GlobalBusinessObject gbo = (GlobalBusinessObject) bo;
    List<PersistableBusinessObject> persistables = gbo.generateGlobalChangesToPersist();

    assertTrue("Global Changes returned should be an empty list.", persistables.isEmpty());
  }
  /**
   * Override the getSections method on this maintainable so that the active field can be set to
   * read-only when a CINV doc has been created with this Milestone Schedule and Milestones
   */
  @Override
  public List getSections(MaintenanceDocument document, Maintainable oldMaintainable) {
    List<Section> sections = super.getSections(document, oldMaintainable);
    MilestoneSchedule milestoneSchedule =
        (MilestoneSchedule) document.getNewMaintainableObject().getBusinessObject();
    Long proposalNumber = milestoneSchedule.getProposalNumber();

    for (Section section : sections) {
      String sectionId = section.getSectionId();
      if (sectionId.equalsIgnoreCase(ArPropertyConstants.MILESTONES_SECTION)) {
        prepareMilestonesTab(section, proposalNumber);
      }
    }

    return sections;
  }
  /**
   * Creates a searchable attribute value for the given property name out of the document XML
   *
   * @param propertyName the name of the property to return
   * @param businessObjectClass the class of the business object maintained
   * @param document the document XML
   * @return a generated SearchableAttributeValue, or null if a value could not be created
   */
  protected DocumentAttribute parseSearchableAttributeValueForPrimaryKey(
      String propertyName,
      Class<? extends BusinessObject> businessObjectClass,
      MaintenanceDocument document) {

    Maintainable maintainable = document.getNewMaintainableObject();
    PersistableBusinessObject bo = maintainable.getBusinessObject();

    final Object propertyValue = ObjectUtils.getPropertyValue(bo, propertyName);
    if (propertyValue == null) return null;

    final WorkflowAttributePropertyResolutionService propertyResolutionService =
        KNSServiceLocator.getWorkflowAttributePropertyResolutionService();
    DocumentAttribute value =
        propertyResolutionService.buildSearchableAttribute(
            businessObjectClass, propertyName, propertyValue);
    return value;
  }
  /**
   * This method validates the question response type and any additional properties related to the
   * response type.
   *
   * @param maintenanceDocument - the maintenance document of the question to be validated
   * @return true if all validation has passed, false otherwise
   */
  private boolean validateQuestionResponseType(MaintenanceDocument maintenanceDocument) {
    boolean isValid = true;

    Question question = (Question) maintenanceDocument.getNewMaintainableObject().getDataObject();

    if (question.getQuestionTypeId() == null) {
      isValid &= false;
      GlobalVariables.getMessageMap()
          .putError(
              Constants.QUESTION_DOCUMENT_FIELD_QUESTION_TYPE_ID,
              KeyConstants.ERROR_QUESTION_RESPONSE_TYPE_NOT_SPECIFIED);
    } else {
      switch (question.getQuestionTypeId()) {
        case Constants.QUESTION_RESPONSE_TYPE_YES_NO:
          isValid &= validateResponseTypeYesNo(question);
          break;
        case Constants.QUESTION_RESPONSE_TYPE_YES_NO_NA:
          isValid &= validateResponseTypeYesNoNa(question);
          break;
        case Constants.QUESTION_RESPONSE_TYPE_NUMBER:
          isValid &= validateResponseTypeNumber(question);
          break;
        case Constants.QUESTION_RESPONSE_TYPE_DATE:
          isValid &= validateResponseTypeDate(question);
          break;
        case Constants.QUESTION_RESPONSE_TYPE_TEXT:
          isValid &= validateResponseTypeText(question);
          break;
        case Constants.QUESTION_RESPONSE_TYPE_LOOKUP:
          isValid &= validateResponseTypeLookup(question);
          break;
        default:
          isValid &= false;
          GlobalVariables.getMessageMap()
              .putError(
                  Constants.QUESTION_DOCUMENT_FIELD_QUESTION_TYPE_ID,
                  KeyConstants.ERROR_QUESTION_RESPONSE_TYPE_INVALID);
          break;
      }
    }

    return isValid;
  }
  @Override
  public void refresh(String refreshCaller, Map fieldValues, MaintenanceDocument document) {

    super.refresh(refreshCaller, fieldValues, document);

    if (StringUtils.isNotEmpty(refreshCaller)
        && refreshCaller.equalsIgnoreCase("achPayeeLookupable")) {
      PayeeACHAccount payeeAchAccount =
          (PayeeACHAccount) document.getNewMaintainableObject().getBusinessObject();
      String payeeIdNumber = payeeAchAccount.getPayeeIdNumber();
      String payeeIdentifierTypeCode = payeeAchAccount.getPayeeIdentifierTypeCode();

      if (StringUtils.isNotEmpty(payeeAchAccount.getPayeeIdNumber())) {
        // for Employee, retrieve from Person table by employee ID
        if (StringUtils.equalsIgnoreCase(payeeIdentifierTypeCode, PayeeIdTypeCodes.EMPLOYEE)) {
          Person person =
              SpringContext.getBean(PersonService.class).getPersonByEmployeeId(payeeIdNumber);
          if (ObjectUtils.isNotNull(person)) {
            payeeAchAccount.setPayeeEmailAddress(person.getEmailAddress());
          }
        }
        // for Entity, retrieve from Entity table by entity ID then from Person table
        else if (StringUtils.equalsIgnoreCase(payeeIdentifierTypeCode, PayeeIdTypeCodes.ENTITY)) {
          if (ObjectUtils.isNotNull(payeeIdNumber)) {
            EntityDefault entity =
                KimApiServiceLocator.getIdentityService().getEntityDefault(payeeIdNumber);
            if (ObjectUtils.isNotNull(entity)) {
              List<Principal> principals = entity.getPrincipals();
              if (principals.size() > 0 && ObjectUtils.isNotNull(principals.get(0))) {
                String principalId = principals.get(0).getPrincipalId();
                Person person = SpringContext.getBean(PersonService.class).getPerson(principalId);
                if (ObjectUtils.isNotNull(person)) {
                  payeeAchAccount.setPayeeEmailAddress(person.getEmailAddress());
                }
              }
            }
          }
        }
      }
    }
  }
  /**
   * Units cannot be moved to its own descendants. This method returns false if it is moving to its
   * own descendants.
   *
   * @param maintenanceDocument
   * @return
   */
  private boolean moveUnit(MaintenanceDocument maintenanceDocument) {

    boolean valid = true;
    Unit unit = (Unit) maintenanceDocument.getNewMaintainableObject().getDataObject();
    String unitNumber = unit.getUnitNumber();
    String parentUnitNumber = unit.getParentUnitNumber();
    List<Unit> allSubUnits =
        KcServiceLocator.getService(UnitService.class).getAllSubUnits(unitNumber);
    for (Unit subunits : allSubUnits) {
      if (subunits.getUnitNumber().equals(parentUnitNumber)) {
        GlobalVariables.getMessageMap()
            .putError(
                "document.newMaintainableObject.parentUnitNumber",
                KeyConstants.MOVE_UNIT_OWN_DESCENDANTS,
                new String[] {unit.getParentUnitNumber(), unit.getParentUnitNumber()});
        valid = false;
      }
    }

    return valid;
  }
  /**
   * @see
   *     org.kuali.rice.kns.maintenance.KualiMaintainableImpl#processAfterCopy(org.kuali.rice.kns.document.MaintenanceDocument,
   *     java.util.Map)
   */
  @Override
  public void processAfterCopy(MaintenanceDocument document, Map<String, String[]> parameters) {
    super.processAfterCopy(document, parameters);
    AgencyStagingData agencyData = (AgencyStagingData) getBusinessObject();
    agencyData.setManualCreated(true);
    agencyData.setCreationTimestamp(getDateTimeService().getCurrentTimestamp());

    AgencyStagingDataMaintainable oldMaintainable =
        (AgencyStagingDataMaintainable) document.getOldMaintainableObject();
    // this is not new, so it must be for copy - we will set the Copied From Id
    agencyData.setCopiedFromId(((AgencyStagingData) oldMaintainable.getBusinessObject()).getId());

    // set TripAccountingInformation primary key and foreign key to null so the maintainance
    // document can handle setting the appropriate key values
    if (!agencyData.getTripAccountingInformation().isEmpty()) {
      for (TripAccountingInformation account : agencyData.getTripAccountingInformation()) {
        account.setId(null);
        account.setAgencyStagingDataId(null);
      }
    }
  }
  protected void addNoteAfterProcessingAgencyStagingExpense(
      MaintenanceDocument document, List<ErrorMessage> errors) {

    Principal kfsSystemUser =
        getIdentityService().getPrincipalByPrincipalName(KFSConstants.SYSTEM_USER);
    String errorText = getMessageAsString(errors);

    if (!StringUtils.isEmpty(errorText)) {
      // check maxLength on a Note and truncate if necessary
      Integer maxLength =
          getDataDictionaryService()
              .getAttributeMaxLength(Note.class, KRADConstants.NOTE_TEXT_PROPERTY_NAME);
      if (errorText.length() > maxLength) {
        LOG.warn("Adding a truncated error text to Note due to space limitations. Original text:");
        LOG.warn(errorText);
        errorText = errorText.substring(0, maxLength);
      }

      final Note newNote = getDocumentService().createNoteFromDocument(document, errorText);
      newNote.setAuthorUniversalIdentifier(kfsSystemUser.getPrincipalId());
      document.addNote(newNote);
      getNoteService().save(newNote);
    }
  }
 /**
  * @see
  *     org.kuali.rice.kns.maintenance.KualiMaintainableImpl#processAfterEdit(org.kuali.rice.kns.document.MaintenanceDocument,
  *     java.util.Map)
  */
 @Override
 public void processAfterPost(MaintenanceDocument document, Map<String, String[]> parameters) {
   updateCreditCardAgency(
       (AgencyStagingData) document.getNewMaintainableObject().getBusinessObject());
   super.processAfterPost(document, parameters);
 }
  private boolean verifyProposaEditableColumnsDataType(MaintenanceDocument maintenanceDocument) {
    ProposalColumnsToAlter newEditableProposalField =
        (ProposalColumnsToAlter) maintenanceDocument.getNewMaintainableObject().getDataObject();
    KcPersistenceStructureService kraPersistenceStructureService =
        KcServiceLocator.getService(KcPersistenceStructureService.class);
    DataDictionaryService dataDictionaryService =
        (DataDictionaryService) KNSServiceLocator.getDataDictionaryService();
    Map<String, String> fieldMap =
        kraPersistenceStructureService.getDBColumnToObjectAttributeMap(ProposalOverview.class);
    DataDictionaryEntry entry =
        dataDictionaryService
            .getDataDictionary()
            .getDictionaryObjectEntry(ProposalDevelopmentDocument.class.getName());

    boolean returnFlag = true;
    String editableProposalField = "";
    Integer fieldMaxLength = -1;
    Integer inputDataLength = -1;
    String proposalFieldDataType = "";
    String inputDataType = "";
    ValidationPattern validatingPattern = null;

    if (newEditableProposalField != null
        && StringUtils.isNotEmpty(newEditableProposalField.getColumnName())) {
      editableProposalField = fieldMap.get(newEditableProposalField.getColumnName());
      if (StringUtils.isNotEmpty(editableProposalField)) {
        if (entry != null) {
          AttributeDefinition attributeDefinition =
              entry.getAttributeDefinition(editableProposalField);
          if (attributeDefinition != null && attributeDefinition.hasValidationPattern()) {
            validatingPattern = attributeDefinition.getValidationPattern();
            if (validatingPattern != null) {
              proposalFieldDataType =
                  validationClassesMap.get(validatingPattern.getClass().getName());
              inputDataType = newEditableProposalField.getDataType();
              if (!proposalFieldDataType.equalsIgnoreCase(inputDataType)) {
                // throw error
                GlobalVariables.getMessageMap()
                    .putError(
                        Constants.PROPOSAL_EDITABLECOLUMN_DATATYPE,
                        KeyConstants.PROPOSAL_EDITABLECOLUMN_DATATYPE_MISMATCH);
                returnFlag = false;
              }
            }
          }
        }

        inputDataLength = newEditableProposalField.getDataLength();
        fieldMaxLength =
            dataDictionaryService.getAttributeMaxLength(
                DevelopmentProposal.class, editableProposalField);
        if (fieldMaxLength > inputDataLength) {
          // throw error
          GlobalVariables.getMessageMap()
              .putError(
                  Constants.PROPOSAL_EDITABLECOLUMN_DATALENGTH,
                  KeyConstants.PROPOSAL_EDITABLECOLUMN_DATALENGTH_MISMATCH);
          returnFlag = false;
        }
      }
    }

    return returnFlag;
  }
  /**
   * This method processes the workflow document actions like save, route and blanket approve
   * depending on the ACCOUNT_AUTO_CREATE_ROUTE system parameter value. If the system parameter
   * value is not of save or submit or blanketapprove, put an error message and quit. Throws an
   * document WorkflowException if the specific document action fails to perform.
   *
   * @param maintenanceAccountDocument, errorMessages
   * @return
   */
  protected void createRouteAutomaticCGAccountDocument(
      MaintenanceDocument maintenanceAccountDocument,
      AccountCreationStatusDTO accountCreationStatus) {

    try {
      String accountAutoCreateRouteValue =
          getParameterService()
              .getParameterValueAsString(
                  Account.class,
                  KcConstants.AccountCreationService
                      .PARAMETER_KC_ACCOUNT_ADMIN_AUTO_CREATE_ACCOUNT_WORKFLOW_ACTION);

      // if the accountAutoCreateRouteValue is not save or submit or blanketApprove then put an
      // error message and quit.
      if (!accountAutoCreateRouteValue.equalsIgnoreCase(KFSConstants.WORKFLOW_DOCUMENT_SAVE)
          && !accountAutoCreateRouteValue.equalsIgnoreCase("submit")
          && !accountAutoCreateRouteValue.equalsIgnoreCase(
              KFSConstants.WORKFLOW_DOCUMENT_BLANKET_APPROVE)) {
        this.setFailStatus(
            accountCreationStatus,
            KcConstants.AccountCreationService
                .ERROR_KC_DOCUMENT_SYSTEM_PARAMETER_INCORRECT_DOCUMENT_ACTION_VALUE);
        LOG.error(
            "Incorrect document status::::: "
                + accountCreationStatus.getErrorMessages().toString());
        return;
      }

      if (accountAutoCreateRouteValue.equalsIgnoreCase(KFSConstants.WORKFLOW_DOCUMENT_SAVE)) {

        // attempt to save if apply rules were successful and there are no errors
        boolean rulesPassed =
            SpringContext.getBean(KualiRuleService.class)
                .applyRules(new SaveDocumentEvent(maintenanceAccountDocument));
        LOG.debug(
            "global variable messages :::  "
                + GlobalVariables.getMessageMap().getErrorMessages().toString());
        if (rulesPassed && GlobalVariables.getMessageMap().hasNoErrors()) {
          getDocumentService().saveDocument(maintenanceAccountDocument);
        } else {
          // get errors from apply rules invocation, also clears global variables
          LOG.info("rule fail formatting errors messages ");
          accountCreationStatus.setErrorMessages(
              GlobalVariablesExtractHelper.extractGlobalVariableErrors());
          try {
            // save document, and catch VE's as we want to do this silently
            getDocumentService().saveDocument(maintenanceAccountDocument);
          } catch (ValidationException ve) {
          }

          accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_SUCCESS);
          LOG.error(
              KcUtils.getErrorMessage(
                  KcConstants.AccountCreationService.ERROR_KC_DOCUMENT_ACCOUNT_RULES_EXCEPTION,
                  new String[] {maintenanceAccountDocument.getDocumentNumber()}));
        }

      } else if (accountAutoCreateRouteValue.equalsIgnoreCase(
          KFSConstants.WORKFLOW_DOCUMENT_BLANKET_APPROVE)) {

        // attempt to blanket approve if apply rules were successful and there are no errors
        boolean rulesPassed =
            SpringContext.getBean(KualiRuleService.class)
                .applyRules(new BlanketApproveDocumentEvent(maintenanceAccountDocument));

        if (rulesPassed && GlobalVariables.getMessageMap().hasNoErrors()) {
          getDocumentService().blanketApproveDocument(maintenanceAccountDocument, "", null);
        } else {
          // get errors from apply rules invocation, also clears global variables
          accountCreationStatus.setErrorMessages(
              GlobalVariablesExtractHelper.extractGlobalVariableErrors());
          try {
            // save document, and catch VE's as we want to do this silently
            getDocumentService().saveDocument(maintenanceAccountDocument);
          } catch (ValidationException ve) {
          }

          accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_SUCCESS);
          LOG.error(
              KcUtils.getErrorMessage(
                  KcConstants.AccountCreationService.ERROR_KC_DOCUMENT_ACCOUNT_RULES_EXCEPTION,
                  new String[] {maintenanceAccountDocument.getDocumentNumber()}));
        }

      } else if (accountAutoCreateRouteValue.equalsIgnoreCase("submit")) {

        // attempt to route if apply rules were successful and there are no errors
        boolean rulesPassed =
            SpringContext.getBean(KualiRuleService.class)
                .applyRules(new RouteDocumentEvent(maintenanceAccountDocument));

        if (rulesPassed && GlobalVariables.getMessageMap().hasNoErrors()) {
          getDocumentService().routeDocument(maintenanceAccountDocument, "", null);
        } else {
          // get errors from apply rules invocation, also clears global variables
          accountCreationStatus.setErrorMessages(
              GlobalVariablesExtractHelper.extractGlobalVariableErrors());
          try {
            // save document, and catch VE's as we want to do this silently
            getDocumentService().saveDocument(maintenanceAccountDocument);
          } catch (ValidationException ve) {
          }

          accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_SUCCESS);
          LOG.error(
              KcUtils.getErrorMessage(
                  KcConstants.AccountCreationService.ERROR_KC_DOCUMENT_ACCOUNT_RULES_EXCEPTION,
                  new String[] {maintenanceAccountDocument.getDocumentNumber()}));
        }
      }

      // set the document number
      accountCreationStatus.setDocumentNumber(maintenanceAccountDocument.getDocumentNumber());

    } catch (WorkflowException wfe) {

      LOG.error(
          KcUtils.getErrorMessage(
                  KcConstants.AccountCreationService
                      .ERROR_KC_DOCUMENT_WORKFLOW_EXCEPTION_DOCUMENT_ACTIONS,
                  null)
              + ": "
              + wfe.getMessage());
      accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_FAILURE);
      accountCreationStatus
          .getErrorMessages()
          .add(
              KcUtils.getErrorMessage(
                      KcConstants.AccountCreationService
                          .WARNING_KC_DOCUMENT_WORKFLOW_EXCEPTION_DOCUMENT_ACTIONS,
                      null)
                  + ": "
                  + wfe.getMessage());

      try {
        // save it even though it fails to route or blanket approve the document
        try {
          getDocumentService().saveDocument(maintenanceAccountDocument);
        } catch (ValidationException ve) {
          // ok to catch validation exceptions at this point
        }
        accountCreationStatus.setDocumentNumber(maintenanceAccountDocument.getDocumentNumber());
        accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_SUCCESS);
      } catch (WorkflowException e) {
        LOG.error(
            KcUtils.getErrorMessage(
                    KcConstants.AccountCreationService
                        .WARNING_KC_DOCUMENT_WORKFLOW_EXCEPTION_DOCUMENT_ACTIONS,
                    null)
                + ": "
                + e.getMessage());
        accountCreationStatus.setErrorMessages(
            GlobalVariablesExtractHelper.extractGlobalVariableErrors());
        accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_FAILURE);
      }

    } catch (Exception ex) {

      LOG.error("Unknown exception occurred: " + ex.getMessage());
      accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_FAILURE);
      accountCreationStatus.setErrorMessages(
          GlobalVariablesExtractHelper.extractGlobalVariableErrors());
      accountCreationStatus
          .getErrorMessages()
          .add(
              KcUtils.getErrorMessage(
                      KcConstants.AccountCreationService
                          .WARNING_KC_DOCUMENT_WORKFLOW_EXCEPTION_DOCUMENT_ACTIONS,
                      null)
                  + ": "
                  + ex.getMessage());

      try {
        // save it even though it fails to route or blanket approve the document
        try {
          getDocumentService().saveDocument(maintenanceAccountDocument);
        } catch (ValidationException ve) {
          // ok to catch validation exceptions at this point
        }
        accountCreationStatus.setDocumentNumber(maintenanceAccountDocument.getDocumentNumber());
        accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_SUCCESS);
      } catch (WorkflowException e) {
        LOG.error(
            KcUtils.getErrorMessage(
                    KcConstants.AccountCreationService
                        .WARNING_KC_DOCUMENT_WORKFLOW_EXCEPTION_DOCUMENT_ACTIONS,
                    null)
                + ": "
                + e.getMessage());
        accountCreationStatus.setErrorMessages(
            GlobalVariablesExtractHelper.extractGlobalVariableErrors());
        accountCreationStatus.setStatus(KcConstants.KcWebService.STATUS_KC_FAILURE);
      }
    }
  }