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