/*
* The Kuali Financial System, a comprehensive financial management system for higher education.
*
* Copyright 2005-2014 The Kuali Foundation
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.kuali.kfs.module.purap.document.web.struts;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;
import org.kuali.kfs.integration.purap.CapitalAssetLocation;
import org.kuali.kfs.integration.purap.CapitalAssetSystem;
import org.kuali.kfs.integration.purap.ItemCapitalAsset;
import org.kuali.kfs.module.purap.PurapConstants;
import org.kuali.kfs.module.purap.PurapKeyConstants;
import org.kuali.kfs.module.purap.PurapParameterConstants;
import org.kuali.kfs.module.purap.PurapPropertyConstants;
import org.kuali.kfs.module.purap.businessobject.BillingAddress;
import org.kuali.kfs.module.purap.businessobject.CapitalAssetSystemType;
import org.kuali.kfs.module.purap.businessobject.PurApAccountingLine;
import org.kuali.kfs.module.purap.businessobject.PurApItem;
import org.kuali.kfs.module.purap.businessobject.PurchaseOrderItem;
import org.kuali.kfs.module.purap.businessobject.PurchasingCapitalAssetItem;
import org.kuali.kfs.module.purap.businessobject.PurchasingCapitalAssetSystemBase;
import org.kuali.kfs.module.purap.businessobject.PurchasingItemBase;
import org.kuali.kfs.module.purap.document.PurchaseOrderAmendmentDocument;
import org.kuali.kfs.module.purap.document.PurchaseOrderDocument;
import org.kuali.kfs.module.purap.document.PurchasingAccountsPayableDocument;
import org.kuali.kfs.module.purap.document.PurchasingAccountsPayableDocumentBase;
import org.kuali.kfs.module.purap.document.PurchasingDocument;
import org.kuali.kfs.module.purap.document.PurchasingDocumentBase;
import org.kuali.kfs.module.purap.document.service.PurapService;
import org.kuali.kfs.module.purap.document.service.PurchaseOrderService;
import org.kuali.kfs.module.purap.document.service.PurchasingService;
import org.kuali.kfs.module.purap.document.validation.event.AttributedAddPurchasingAccountsPayableItemEvent;
import org.kuali.kfs.module.purap.document.validation.event.AttributedAddPurchasingCapitalAssetLocationEvent;
import org.kuali.kfs.module.purap.document.validation.event.AttributedAddPurchasingItemCapitalAssetEvent;
import org.kuali.kfs.module.purap.document.validation.event.AttributedCommodityCodesForDistributionEvent;
import org.kuali.kfs.module.purap.document.validation.event.AttributedImportPurchasingAccountsPayableItemEvent;
import org.kuali.kfs.module.purap.document.validation.event.AttributedUpdateCamsViewPurapEvent;
import org.kuali.kfs.module.purap.exception.ItemParserException;
import org.kuali.kfs.module.purap.service.PurapAccountingService;
import org.kuali.kfs.module.purap.util.ItemParser;
import org.kuali.kfs.module.purap.util.PurApArrayList;
import org.kuali.kfs.sys.KFSConstants;
import org.kuali.kfs.sys.KFSKeyConstants;
import org.kuali.kfs.sys.KFSPropertyConstants;
import org.kuali.kfs.sys.businessobject.Building;
import org.kuali.kfs.sys.businessobject.SourceAccountingLine;
import org.kuali.kfs.sys.context.SpringContext;
import org.kuali.kfs.sys.document.validation.event.AddAccountingLineEvent;
import org.kuali.kfs.sys.service.impl.KfsParameterConstants;
import org.kuali.kfs.vnd.VendorConstants;
import org.kuali.kfs.vnd.VendorPropertyConstants;
import org.kuali.kfs.vnd.businessobject.VendorAddress;
import org.kuali.kfs.vnd.businessobject.VendorContract;
import org.kuali.kfs.vnd.document.service.VendorService;
import org.kuali.kfs.vnd.service.PhoneNumberService;
import org.kuali.rice.core.api.config.property.ConfigurationService;
import org.kuali.rice.core.api.util.type.KualiDecimal;
import org.kuali.rice.coreservice.framework.parameter.ParameterService;
import org.kuali.rice.kew.api.exception.WorkflowException;
import org.kuali.rice.kns.question.ConfirmationQuestion;
import org.kuali.rice.kns.service.DataDictionaryService;
import org.kuali.rice.kns.util.KNSGlobalVariables;
import org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase;
import org.kuali.rice.krad.bo.Note;
import org.kuali.rice.krad.bo.PersistableBusinessObject;
import org.kuali.rice.krad.document.Document;
import org.kuali.rice.krad.service.BusinessObjectService;
import org.kuali.rice.krad.service.KualiRuleService;
import org.kuali.rice.krad.service.PersistenceService;
import org.kuali.rice.krad.util.GlobalVariables;
import org.kuali.rice.krad.util.KRADConstants;
import org.kuali.rice.krad.util.MessageMap;
import org.kuali.rice.krad.util.ObjectUtils;
/**
* Struts Action for Purchasing documents.
*/
public class PurchasingActionBase extends PurchasingAccountsPayableActionBase {
protected static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(PurchasingActionBase.class);
/**
* @see org.kuali.kfs.sys.web.struts.KualiAccountingDocumentActionBase#refresh(org.apache.struts.action.ActionMapping,
* org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
@Override
public ActionForward refresh(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase baseForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) baseForm.getDocument();
String refreshCaller = baseForm.getRefreshCaller();
BusinessObjectService businessObjectService = SpringContext.getBean(BusinessObjectService.class);
PhoneNumberService phoneNumberService = SpringContext.getBean(PhoneNumberService.class);
// Format phone numbers
document.setInstitutionContactPhoneNumber(phoneNumberService.formatNumberIfPossible(document.getInstitutionContactPhoneNumber()));
document.setRequestorPersonPhoneNumber(phoneNumberService.formatNumberIfPossible(document.getRequestorPersonPhoneNumber()));
document.setDeliveryToPhoneNumber(phoneNumberService.formatNumberIfPossible(document.getDeliveryToPhoneNumber()));
// names in KIM are longer than what we store these names at; truncate them to match our data dictionary maxlengths
if (StringUtils.equals(refreshCaller, "kimPersonLookupable")) {
Integer deliveryToNameMaxLength = SpringContext.getBean(DataDictionaryService.class).getAttributeMaxLength(document.getClass(), PurapPropertyConstants.DELIVERY_TO_NAME);
if (StringUtils.isNotEmpty(document.getDeliveryToName()) && ObjectUtils.isNotNull(deliveryToNameMaxLength) && document.getDeliveryToName().length() > deliveryToNameMaxLength.intValue()) {
document.setDeliveryToName(document.getDeliveryToName().substring(0, deliveryToNameMaxLength));
GlobalVariables.getMessageMap().clearErrorPath();
GlobalVariables.getMessageMap().addToErrorPath(PurapConstants.DELIVERY_TAB_ERRORS);
GlobalVariables.getMessageMap().putWarning(PurapPropertyConstants.DELIVERY_TO_NAME, PurapKeyConstants.WARNING_DELIVERY_TO_NAME_TRUNCATED);
GlobalVariables.getMessageMap().removeFromErrorPath(PurapConstants.DELIVERY_TAB_ERRORS);
}
Integer requestorNameMaxLength = SpringContext.getBean(DataDictionaryService.class).getAttributeMaxLength(document.getClass(), PurapPropertyConstants.REQUESTOR_PERSON_NAME);
if (StringUtils.isNotEmpty(document.getRequestorPersonName()) && ObjectUtils.isNotNull(requestorNameMaxLength) && document.getRequestorPersonName().length() > requestorNameMaxLength.intValue()) {
document.setRequestorPersonName(document.getRequestorPersonName().substring(0, requestorNameMaxLength));
GlobalVariables.getMessageMap().clearErrorPath();
GlobalVariables.getMessageMap().addToErrorPath(PurapConstants.ADDITIONAL_TAB_ERRORS);
GlobalVariables.getMessageMap().putWarning(PurapPropertyConstants.REQUESTOR_PERSON_NAME, PurapKeyConstants.WARNING_REQUESTOR_NAME_TRUNCATED);
GlobalVariables.getMessageMap().removeFromErrorPath(PurapConstants.ADDITIONAL_TAB_ERRORS);
}
}
// Refreshing the fields after returning from a vendor lookup in the vendor tab
if (StringUtils.equals(refreshCaller, VendorConstants.VENDOR_LOOKUPABLE_IMPL) && document.getVendorDetailAssignedIdentifier() != null && document.getVendorHeaderGeneratedIdentifier() != null) {
document.setVendorContractGeneratedIdentifier(null);
document.refreshReferenceObject("vendorContract");
// retrieve vendor based on selection from vendor lookup
document.refreshReferenceObject("vendorDetail");
document.templateVendorDetail(document.getVendorDetail());
// populate default address based on selected vendor
VendorAddress defaultAddress = SpringContext.getBean(VendorService.class).getVendorDefaultAddress(document.getVendorDetail().getVendorAddresses(), document.getVendorDetail().getVendorHeader().getVendorType().getAddressType().getVendorAddressTypeCode(), document.getDeliveryCampusCode());
if(defaultAddress==null){
GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DOC_ADDRESS, PurapKeyConstants.ERROR_INACTIVE_VENDORADDRESS);
}
document.templateVendorAddress(defaultAddress);
}
// Refreshing the fields after returning from a contract lookup in the vendor tab
if (StringUtils.equals(refreshCaller, VendorConstants.VENDOR_CONTRACT_LOOKUPABLE_IMPL)) {
if (StringUtils.isNotEmpty(request.getParameter(KFSPropertyConstants.DOCUMENT + "." + PurapPropertyConstants.VENDOR_CONTRACT_ID))) {
// retrieve Contract based on selection from contract lookup
VendorContract refreshVendorContract = new VendorContract();
refreshVendorContract.setVendorContractGeneratedIdentifier(document.getVendorContractGeneratedIdentifier());
refreshVendorContract = (VendorContract) businessObjectService.retrieve(refreshVendorContract);
// retrieve Vendor based on selected contract
document.setVendorHeaderGeneratedIdentifier(refreshVendorContract.getVendorHeaderGeneratedIdentifier());
document.setVendorDetailAssignedIdentifier(refreshVendorContract.getVendorDetailAssignedIdentifier());
document.refreshReferenceObject("vendorDetail");
document.templateVendorDetail(document.getVendorDetail());
// always template contract after vendor to keep contract defaults last
document.templateVendorContract(refreshVendorContract);
// populate default address from selected vendor
VendorAddress defaultAddress = SpringContext.getBean(VendorService.class).getVendorDefaultAddress(document.getVendorDetail().getVendorAddresses(), document.getVendorDetail().getVendorHeader().getVendorType().getAddressType().getVendorAddressTypeCode(), "");
if(defaultAddress==null){
GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DOC_ADDRESS, PurapKeyConstants.ERROR_INACTIVE_VENDORADDRESS);
}
document.templateVendorAddress(defaultAddress);
// update internal dollar limit for PO since the contract might affect this value
if (document instanceof PurchaseOrderDocument) {
PurchaseOrderDocument poDoc = (PurchaseOrderDocument) document;
KualiDecimal limit = SpringContext.getBean(PurchaseOrderService.class).getInternalPurchasingDollarLimit(poDoc);
poDoc.setInternalPurchasingLimit(limit);
}
}
}
// Refreshing the fields after returning from an address lookup in the vendor tab
if (StringUtils.equals(refreshCaller, VendorConstants.VENDOR_ADDRESS_LOOKUPABLE_IMPL)) {
if (StringUtils.isNotEmpty(request.getParameter(KFSPropertyConstants.DOCUMENT + "." + PurapPropertyConstants.VENDOR_ADDRESS_ID))) {
// retrieve address based on selection from address lookup
VendorAddress refreshVendorAddress = new VendorAddress();
refreshVendorAddress.setVendorAddressGeneratedIdentifier(document.getVendorAddressGeneratedIdentifier());
refreshVendorAddress = (VendorAddress) businessObjectService.retrieve(refreshVendorAddress);
document.templateVendorAddress(refreshVendorAddress);
}
}
// Refreshing corresponding fields after returning from various kuali lookups
if (StringUtils.equals(refreshCaller, KFSConstants.KUALI_LOOKUPABLE_IMPL)) {
if (request.getParameter("document.deliveryCampusCode") != null) {
// returning from a building or campus lookup on the delivery tab (update billing address)
BillingAddress billingAddress = new BillingAddress();
billingAddress.setBillingCampusCode(document.getDeliveryCampusCode());
Map keys = SpringContext.getBean(PersistenceService.class).getPrimaryKeyFieldValues(billingAddress);
billingAddress = SpringContext.getBean(BusinessObjectService.class).findByPrimaryKey(BillingAddress.class, keys);
document.templateBillingAddress(billingAddress);
if (request.getParameter("document.deliveryBuildingName") == null) {
// came from campus lookup not building, so clear building
document.setDeliveryBuildingCode("");
document.setDeliveryBuildingName("");
document.setDeliveryBuildingLine1Address("");
document.setDeliveryBuildingLine2Address("");
document.setDeliveryBuildingRoomNumber("");
document.setDeliveryCityName("");
document.setDeliveryStateCode("");
document.setDeliveryPostalCode("");
document.setDeliveryCountryCode("");
}
else {
// came from building lookup then turn off "OTHER" and clear room and line2address
document.setDeliveryBuildingOtherIndicator(false);
document.setDeliveryBuildingRoomNumber("");
document.setDeliveryBuildingLine2Address("");
}
}
else if (request.getParameter("document.chartOfAccountsCode") != null) {
// returning from a chart/org lookup on the document detail tab (update receiving address)
document.loadReceivingAddress();
}
else {
String buildingCodeParam = findBuildingCodeFromCapitalAssetBuildingLookup(request);
if (!StringUtils.isEmpty(buildingCodeParam)) {
// returning from a building lookup in a capital asset tab location (update location address)
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
CapitalAssetLocation location = null;
// get building code
String buildingCode = request.getParameterValues(buildingCodeParam)[0];
// get campus code
String campusCodeParam = buildingCodeParam.replace("buildingCode", "campusCode");
String campusCode = request.getParameterValues(campusCodeParam)[0];
// lookup building
Building locationBuilding = new Building();
locationBuilding.setCampusCode(campusCode);
locationBuilding.setBuildingCode(buildingCode);
Map<String, String> keys = SpringContext.getBean(PersistenceService.class).getPrimaryKeyFieldValues(locationBuilding);
locationBuilding = SpringContext.getBean(BusinessObjectService.class).findByPrimaryKey(Building.class, keys);
Map<String, String> parameters = request.getParameterMap();
Set<String> parameterKeys = parameters.keySet();
String locationCapitalAssetLocationNumber = "";
String locationCapitalAssetItemNumber = "";
for (String parameterKey : parameterKeys) {
if (StringUtils.containsIgnoreCase(parameterKey, "newPurchasingCapitalAssetLocationLine")) {
// its the new line
if (document.getCapitalAssetSystemType().getCapitalAssetSystemTypeCode().equals(PurapConstants.CapitalAssetSystemTypes.INDIVIDUAL)) {
// get the item number
locationCapitalAssetItemNumber = getCaptialAssetItemNumberFromParameter(parameterKey);
PurchasingCapitalAssetItem capitalAssetItem = document.getPurchasingCapitalAssetItems().get(Integer.parseInt(locationCapitalAssetItemNumber));
location = capitalAssetItem.getPurchasingCapitalAssetSystem().getNewPurchasingCapitalAssetLocationLine();
}
else {
// no item number
location = purchasingForm.getNewPurchasingCapitalAssetLocationLine();
}
break;
}
else if (StringUtils.containsIgnoreCase(parameterKey, "purchasingCapitalAssetLocationLine")) {
// its one of the numbered lines, lets
locationCapitalAssetLocationNumber = getCaptialAssetLocationNumberFromParameter(parameterKey);
if (document.getCapitalAssetSystemType().getCapitalAssetSystemTypeCode().equals(PurapConstants.CapitalAssetSystemTypes.INDIVIDUAL)) {
// get the item number
locationCapitalAssetItemNumber = getCaptialAssetItemNumberFromParameter(parameterKey);
PurchasingCapitalAssetItem capitalAssetItem = document.getPurchasingCapitalAssetItems().get(Integer.parseInt(locationCapitalAssetItemNumber));
location = capitalAssetItem.getPurchasingCapitalAssetSystem().getCapitalAssetLocations().get(Integer.parseInt(locationCapitalAssetLocationNumber));
}
break;
}
else if (StringUtils.containsIgnoreCase(parameterKey, "purchasingCapitalAssetSystems")) {
// its one of the numbered lines, lets
locationCapitalAssetLocationNumber = getCaptialAssetLocationNumberFromParameter(parameterKey);
if (!document.getCapitalAssetSystemType().getCapitalAssetSystemTypeCode().equals(PurapConstants.CapitalAssetSystemTypes.INDIVIDUAL)) {
CapitalAssetSystem capitalAssetSystem = document.getPurchasingCapitalAssetSystems().get(0);
location = capitalAssetSystem.getCapitalAssetLocations().get(Integer.parseInt(locationCapitalAssetLocationNumber));
}
break;
}
}
if ((location != null) && (locationBuilding != null)) {
location.templateBuilding(locationBuilding);
}
}
}
}
return super.refresh(mapping, form, request, response);
}
protected String getCaptialAssetLocationNumberFromParameter(String parameterKey) {
int beginIndex = parameterKey.lastIndexOf("[") + 1;
int endIndex = parameterKey.lastIndexOf("]");
return parameterKey.substring(beginIndex, endIndex);
}
protected String getCaptialAssetItemNumberFromParameter(String parameterKey) {
int beginIndex = parameterKey.indexOf("[") + 1;
int endIndex = parameterKey.indexOf("]");
return parameterKey.substring(beginIndex, endIndex);
}
/**
* Setup document to use "OTHER" building
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request A HttpServletRequest
* @param response A HttpServletResponse
* @return An ActionForward
* @throws Exception
*/
public ActionForward useOtherDeliveryBuilding(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase baseForm = (PurchasingFormBase) form;
PurchasingDocument document = (PurchasingDocument) baseForm.getDocument();
document.setDeliveryBuildingOtherIndicator(true);
document.setDeliveryBuildingName("");
document.setDeliveryBuildingCode("");
document.setDeliveryBuildingLine1Address("");
document.setDeliveryBuildingLine2Address("");
document.setDeliveryBuildingRoomNumber("");
document.setDeliveryCityName("");
document.setDeliveryStateCode("");
document.setDeliveryCountryCode("");
document.setDeliveryPostalCode("");
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward useOffCampusAssetLocationBuildingByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase baseForm = (PurchasingFormBase) form;
PurchasingDocument document = (PurchasingDocument) baseForm.getDocument();
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String systemIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
String assetLocationIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
CapitalAssetSystem system = document.getPurchasingCapitalAssetSystems().get(Integer.parseInt(systemIndex));
if ("new".equals(assetLocationIndex)) {
useOffCampusAssetLocationBuilding(baseForm.getNewPurchasingCapitalAssetLocationLine());
}
else {
useOffCampusAssetLocationBuilding(system.getCapitalAssetLocations().get(Integer.parseInt(assetLocationIndex)));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward useOffCampusAssetLocationBuildingByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase baseForm = (PurchasingFormBase) form;
PurchasingDocument document = (PurchasingDocument) baseForm.getDocument();
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String assetItemIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
String assetLocationIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
PurchasingCapitalAssetItem assetItem = document.getPurchasingCapitalAssetItems().get(Integer.parseInt(assetItemIndex));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
if ("new".equals(assetLocationIndex)) {
useOffCampusAssetLocationBuilding(system.getNewPurchasingCapitalAssetLocationLine());
}
else {
useOffCampusAssetLocationBuilding(system.getCapitalAssetLocations().get(Integer.parseInt(assetLocationIndex)));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
protected void useOffCampusAssetLocationBuilding(CapitalAssetLocation location) {
if (location != null) {
location.setOffCampusIndicator(true);
location.setBuildingCode("");
location.setCapitalAssetLine1Address("");
location.setCapitalAssetCityName("");
location.setCapitalAssetStateCode("");
location.setCapitalAssetPostalCode("");
location.setCapitalAssetCountryCode("");
location.setBuildingRoomNumber("");
}
}
/**
* Add a new item to the document.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward addItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurApItem item = purchasingForm.getNewPurchasingItemLine();
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedAddPurchasingAccountsPayableItemEvent("", purDocument, item));
if (rulePassed) {
item = purchasingForm.getAndResetNewPurchasingItemLine();
purDocument.addItem(item);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Import items to the document from a spreadsheet.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward importItems(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
LOG.info("Importing item lines");
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
String documentNumber = purDocument.getDocumentNumber();
FormFile itemFile = purchasingForm.getItemImportFile();
Class itemClass = purDocument.getItemClass();
List<PurApItem> importedItems = null;
String errorPath = PurapConstants.ITEM_TAB_ERRORS;
ItemParser itemParser = purDocument.getItemParser();
int itemLinePosition = purDocument.getItemLinePosition(); // starting position of the imported items, equals the # of
// existing above-the-line items.
try {
importedItems = itemParser.importItems(itemFile, itemClass, documentNumber);
// validate imported items
boolean allPassed = true;
int itemLineNumber = 0;
for (PurApItem item : importedItems) {
// Before the validation, set the item line number to the same as the line number in the import file (starting from
// 1)
// so that the error message will use the correct line number if there're errors for the current item line.
item.setItemLineNumber(++itemLineNumber);
allPassed &= SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedImportPurchasingAccountsPayableItemEvent("", purDocument, item));
// After the validation, set the item line number to the correct value as if it's added to the item list.
item.setItemLineNumber(itemLineNumber + itemLinePosition);
}
if (allPassed) {
updateBOReferenceforNewItems(importedItems, (PurchasingDocumentBase) purDocument);
purDocument.getItems().addAll(itemLinePosition, importedItems);
}
}
catch (ItemParserException e) {
GlobalVariables.getMessageMap().putError(errorPath, e.getErrorKey(), e.getErrorParameters());
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Whenever add a new item, we need to keep track of the reference from Item to Doc and from Account to Item
*
* @param importedItems
*/
protected void updateBOReferenceforNewItems(List<PurApItem> importedItems, PurchasingDocumentBase purDocument) {
// update reference from Item to Document and from Account to Item.
for (PurApItem item : importedItems) {
item.setPurapDocument(purDocument);
// set the PurapDocumentIdentifier so in the future, item acquire the object again by calling refreshReferenceObject for
// purApDocument.
if (purDocument.getPurapDocumentIdentifier() != null) {
item.setPurapDocumentIdentifier(purDocument.getPurapDocumentIdentifier());
}
for (PurApAccountingLine account : item.getSourceAccountingLines()) {
account.setPurapItem(item);
if (item.getItemIdentifier() != null) {
account.setItemIdentifier(item.getItemIdentifier());
}
}
}
}
/**
* Delete an item from the document.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward deleteItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
if (!purDocument.getPurchasingCapitalAssetItems().isEmpty()) {
purDocument.setPurchasingCapitalAssetItems(new PurApArrayList(purDocument.getPurchasingCapitalAssetItemClass()));
SpringContext.getBean(PurapService.class).saveDocumentNoValidation(purDocument);
}
// End
purDocument.deleteItem(getSelectedLine(request));
if (StringUtils.isNotBlank(purDocument.getCapitalAssetSystemTypeCode())) {
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedUpdateCamsViewPurapEvent(purDocument));
if (rulePassed) {
SpringContext.getBean(PurchasingService.class).setupCapitalAssetItems(purDocument);
}
}
// End
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Moves the selected item up one position.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward upItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
int line = getSelectedLine(request);
purDocument.itemSwap(line, line - 1);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Moves the selected item down one position (These two methods up/down could easily be consolidated. For now, it seems more
* straightforward to keep them separate.)
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward downItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
int line = getSelectedLine(request);
purDocument.itemSwap(line, line + 1);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Reveals the account distribution section.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward setupAccountDistribution(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
purchasingForm.setHideDistributeAccounts(false);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Clear out the accounting lines from all the items.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward removeAccounts(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
Object question = request.getParameter(PurapConstants.QUESTION_INDEX);
Object buttonClicked = request.getParameter(KFSConstants.QUESTION_CLICKED_BUTTON);
if (question == null) {
String questionText = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(PurapConstants.QUESTION_REMOVE_ACCOUNTS);
return this.performQuestionWithoutInput(mapping, form, request, response, PurapConstants.REMOVE_ACCOUNTS_QUESTION, questionText, KFSConstants.CONFIRMATION_QUESTION, KFSConstants.ROUTE_METHOD, "0");
}
else if (ConfirmationQuestion.YES.equals(buttonClicked)) {
for (PurApItem item : ((PurchasingAccountsPayableDocument) purchasingForm.getDocument()).getItems()) {
item.getSourceAccountingLines().clear();
}
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PURAP_GENERAL_ACCOUNTS_REMOVED);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Clear out the commodity codes from all the items.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward clearItemsCommodityCodes(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
Object question = request.getParameter(PurapConstants.QUESTION_INDEX);
Object buttonClicked = request.getParameter(KFSConstants.QUESTION_CLICKED_BUTTON);
if (question == null) {
String questionText = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(PurapConstants.QUESTION_CLEAR_ALL_COMMODITY_CODES);
return this.performQuestionWithoutInput(mapping, form, request, response, PurapConstants.CLEAR_COMMODITY_CODES_QUESTION, questionText, KFSConstants.CONFIRMATION_QUESTION, KFSConstants.ROUTE_METHOD, "0");
}
else if (ConfirmationQuestion.YES.equals(buttonClicked)) {
for (PurApItem item : ((PurchasingAccountsPayableDocument) purchasingForm.getDocument()).getItems()) {
PurchasingItemBase purItem = ((PurchasingItemBase) item);
purItem.setPurchasingCommodityCode(null);
purItem.setCommodityCode(null);
}
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PUR_COMMODITY_CODES_CLEARED);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Validates that the accounting lines while a distribute accounts action is being taken.
*
* @param document
* @param distributionsourceAccountingLines
* @return
*/
protected boolean validateDistributeAccounts(Document document, List<PurApAccountingLine> distributionsourceAccountingLines) {
boolean rulePassed = true;
String errorPrefix = null;
int i = 0;
for (PurApAccountingLine accountingLine : distributionsourceAccountingLines) {
errorPrefix = "accountDistributionsourceAccountingLine" + "[" + Integer.toString(i) + "]";
rulePassed &= SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent(errorPrefix, document, accountingLine));
i++;
}
return rulePassed;
}
/**
* Distribute accounting line(s) to the item(s). Does not distribute the accounting line(s) to an item if there are already
* accounting lines associated with that item, if the item is a below-the-line item and has no unit cost, or if the item is
* inactive. Distribute commodity code to the item(s). Does not distribute the commodity code to an item if the item is not
* above the line item, is inactive or if the commodity code fails the validation (i.e. inactive commodity code or non existence
* commodity code).
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward doDistribution(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
boolean needToDistributeCommodityCode = false;
if (StringUtils.isNotBlank(purchasingForm.getDistributePurchasingCommodityCode())) {
// Do the logic for distributing purchasing commodity code to all the items.
needToDistributeCommodityCode = true;
}
boolean needToDistributeAccount = false;
List<PurApAccountingLine> distributionsourceAccountingLines = purchasingForm.getAccountDistributionsourceAccountingLines();
if (distributionsourceAccountingLines.size() > 0) {
needToDistributeAccount = true;
}
if (needToDistributeAccount || needToDistributeCommodityCode) {
PurchasingAccountsPayableDocumentBase purApDocument = (PurchasingAccountsPayableDocumentBase) purchasingForm.getDocument();
boolean institutionNeedsDistributeAccountValidation = SpringContext.getBean(ParameterService.class).getParameterValueAsBoolean(KfsParameterConstants.PURCHASING_DOCUMENT.class, PurapParameterConstants.VALIDATE_ACCOUNT_DISTRIBUTION_IND);
boolean foundAccountDistributionError = false;
boolean foundCommodityCodeDistributionError = false;
boolean performedAccountDistribution = false;
boolean performedCommodityCodeDistribution = false;
// do check for account percents only if distribution method not equal to "P"
if (!PurapConstants.AccountDistributionMethodCodes.PROPORTIONAL_CODE.equalsIgnoreCase(purApDocument.getAccountDistributionMethod())) {
// If the institution's validate account distribution indicator is true and
// the total percentage in the distribute account list does not equal 100 % then we should display error
if (institutionNeedsDistributeAccountValidation && needToDistributeAccount && purchasingForm.getTotalPercentageOfAccountDistributionsourceAccountingLines().compareTo(new BigDecimal(100)) != 0) {
GlobalVariables.getMessageMap().putError(PurapConstants.ACCOUNT_DISTRIBUTION_ERROR_KEY, PurapKeyConstants.ERROR_DISTRIBUTE_ACCOUNTS_NOT_100_PERCENT);
foundAccountDistributionError = true;
}
}
// if the institution's validate account distribution indicator is true and
// there is a validation error in the accounts to distribute then we should display an error
if (institutionNeedsDistributeAccountValidation && needToDistributeAccount && (validateDistributeAccounts(purchasingForm.getDocument(), distributionsourceAccountingLines) == false)) {
foundAccountDistributionError = true;
}
for (PurApItem item : ((PurchasingAccountsPayableDocument) purchasingForm.getDocument()).getItems()) {
boolean itemIsActive = true;
if (item instanceof PurchaseOrderItem) {
// if item is PO item... only validate active items
itemIsActive = ((PurchaseOrderItem) item).isItemActiveIndicator();
}
if (needToDistributeCommodityCode) {
// only the above the line items need the commodity code.
if (item.getItemType().isLineItemIndicator() && StringUtils.isBlank(((PurchasingItemBase) item).getPurchasingCommodityCode()) && itemIsActive) {
// Ideally we should invoke rules to check whether the commodity code is valid (active, not restricted,
// not missing, etc), probably somewhere here or invoke the rule class from here.
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedCommodityCodesForDistributionEvent("", purchasingForm.getDocument(), purchasingForm.getDistributePurchasingCommodityCode()));
if (rulePassed) {
((PurchasingItemBase) item).setPurchasingCommodityCode(purchasingForm.getDistributePurchasingCommodityCode());
performedCommodityCodeDistribution = true;
}
else {
foundCommodityCodeDistributionError = true;
}
}
else if (item.getItemType().isLineItemIndicator() && !StringUtils.isBlank(((PurchasingItemBase) item).getPurchasingCommodityCode()) && itemIsActive) {
// could not apply to line, as it wasn't blank
foundCommodityCodeDistributionError = true;
}
}
if (needToDistributeAccount && !foundAccountDistributionError) {
BigDecimal zero = new BigDecimal(0);
// We should be distributing accounting lines to above the line items all the time;
// but only to the below the line items when there is a unit cost.
boolean unitCostNotZeroForBelowLineItems = item.getItemType().isLineItemIndicator() ? true : item.getItemUnitPrice() != null && zero.compareTo(item.getItemUnitPrice()) < 0;
Document document = ((PurchasingFormBase) form).getDocument();
Class clazz = document instanceof PurchaseOrderAmendmentDocument ? PurchaseOrderDocument.class : document.getClass();
List<String> typesNotAllowingEdit = new ArrayList<String>(SpringContext.getBean(ParameterService.class).getParameterValuesAsString(clazz, PurapParameterConstants.PURAP_ITEM_TYPES_RESTRICTING_ACCOUNT_EDIT));
boolean itemOnExcludeList = (typesNotAllowingEdit == null) ? false : typesNotAllowingEdit.contains(item.getItemTypeCode());
if (item.getSourceAccountingLines().size() == 0 && unitCostNotZeroForBelowLineItems && !itemOnExcludeList && itemIsActive) {
for (PurApAccountingLine purApAccountingLine : distributionsourceAccountingLines) {
item.getSourceAccountingLines().add((PurApAccountingLine) ObjectUtils.deepCopy(purApAccountingLine));
}
performedAccountDistribution = true;
}
}
}
if ((needToDistributeCommodityCode && performedCommodityCodeDistribution && !foundCommodityCodeDistributionError) || (needToDistributeAccount && performedAccountDistribution && !foundAccountDistributionError)) {
if (needToDistributeCommodityCode && !foundCommodityCodeDistributionError && performedCommodityCodeDistribution) {
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PUR_COMMODITY_CODE_DISTRIBUTED);
purchasingForm.setDistributePurchasingCommodityCode(null);
}
if (needToDistributeAccount && !foundAccountDistributionError && performedAccountDistribution) {
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PURAP_GENERAL_ACCOUNTS_DISTRIBUTED);
distributionsourceAccountingLines.clear();
}
purchasingForm.setHideDistributeAccounts(true);
}
if ((needToDistributeAccount && !performedAccountDistribution && foundAccountDistributionError)) {
GlobalVariables.getMessageMap().putError(PurapConstants.ACCOUNT_DISTRIBUTION_ERROR_KEY, PurapKeyConstants.PURAP_GENERAL_NO_ITEMS_TO_DISTRIBUTE_TO, "account numbers");
}
if (needToDistributeCommodityCode && !performedCommodityCodeDistribution && foundCommodityCodeDistributionError) {
GlobalVariables.getMessageMap().putError(PurapConstants.ITEM_PURCHASING_COMMODITY_CODE, PurapKeyConstants.PURAP_GENERAL_NO_ITEMS_TO_DISTRIBUTE_TO, "commodity codes");
}
}
else {
GlobalVariables.getMessageMap().putError(PurapConstants.ACCOUNT_DISTRIBUTION_ERROR_KEY, PurapKeyConstants.PURAP_GENERAL_NO_ACCOUNTS_TO_DISTRIBUTE);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Simply hides the account distribution section.
*
* @param mapping An ActionMapping
* @param form An ActionForm
* @param request The HttpServletRequest
* @param response The HttpServletResponse
* @throws Exception
* @return An ActionForward
*/
public ActionForward cancelAccountDistribution(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
purchasingForm.setHideDistributeAccounts(true);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* @see org.kuali.kfs.module.purap.document.web.struts.PurchasingAccountsPayableActionBase#processCustomInsertAccountingLine(org.kuali.kfs.module.purap.document.web.struts.PurchasingAccountsPayableFormBase)
*/
@Override
public boolean processCustomInsertAccountingLine(PurchasingAccountsPayableFormBase purapForm, HttpServletRequest request) {
boolean success = false;
PurchasingFormBase purchasingForm = (PurchasingFormBase) purapForm;
// index of item selected
int itemIndex = getSelectedLine(request);
PurApItem item = null;
boolean institutionNeedsDistributeAccountValidation = SpringContext.getBean(ParameterService.class).getParameterValueAsBoolean(KfsParameterConstants.PURCHASING_DOCUMENT.class, PurapParameterConstants.VALIDATE_ACCOUNT_DISTRIBUTION_IND);
if (itemIndex == -2 && !institutionNeedsDistributeAccountValidation) {
PurApAccountingLine line = purchasingForm.getAccountDistributionnewSourceLine();
purchasingForm.addAccountDistributionsourceAccountingLine(line);
success = true;
}
return success;
}
/**
* @see org.kuali.kfs.sys.web.struts.KualiAccountingDocumentActionBase#deleteSourceLine(org.apache.struts.action.ActionMapping,
* org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
@Override
public ActionForward deleteSourceLine(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
String[] indexes = getSelectedLineForAccounts(request);
int itemIndex = Integer.parseInt(indexes[0]);
int accountIndex = Integer.parseInt(indexes[1]);
if (itemIndex == -2) {
purchasingForm.getAccountDistributionsourceAccountingLines().remove(accountIndex);
}
else {
PurApItem item = ((PurchasingAccountsPayableDocument) purchasingForm.getDocument()).getItem((itemIndex));
item.getSourceAccountingLines().remove(accountIndex);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Sets the line for account distribution.
*
* @param accountIndex The index of the account into the request parameter
* @param purchasingAccountsPayableForm A form which inherits from PurchasingAccountsPayableFormBase
* @return A SourceAccountingLine
*/
@Override
protected SourceAccountingLine customAccountRetrieval(int accountIndex, PurchasingAccountsPayableFormBase purchasingAccountsPayableForm) {
PurchasingFormBase purchasingForm = (PurchasingFormBase) purchasingAccountsPayableForm;
SourceAccountingLine line;
line = (SourceAccountingLine) ObjectUtils.deepCopy(purchasingForm.getAccountDistributionsourceAccountingLines().get(accountIndex));
return line;
}
/**
* This method...
*
* @param mapping
* @param form
* @param request
* @param response
* @return
* @throws Exception
*/
public ActionForward selectSystemType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocumentBase document = (PurchasingDocumentBase) purchasingForm.getDocument();
Object question = request.getParameter(PurapConstants.QUESTION_INDEX);
Object buttonClicked = request.getParameter(KFSConstants.QUESTION_CLICKED_BUTTON);
String systemTypeCode = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
systemTypeCode = StringUtils.substringBetween(systemTypeCode, "selectSystemType.", ".");
if (question == null) {
String questionText = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(PurapConstants.CapitalAssetTabStrings.QUESTION_SYSTEM_SWITCHING);
return this.performQuestionWithoutInput(mapping, form, request, response, PurapConstants.CapitalAssetTabStrings.SYSTEM_SWITCHING_QUESTION, questionText, KFSConstants.CONFIRMATION_QUESTION, KFSConstants.ROUTE_METHOD, "0");
}
else if (ConfirmationQuestion.YES.equals(buttonClicked)) {
// document.setCapitalAssetSystemTypeCode(systemTypeCode);
document.refreshReferenceObject(PurapPropertyConstants.CAPITAL_ASSET_SYSTEM_TYPE);
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PUR_CAPITAL_ASSET_SYSTEM_TYPE_SWITCHED);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward addItemCapitalAssetByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
ItemCapitalAsset asset = purDocument.getPurchasingCapitalAssetItems().get(0).getNewPurchasingItemCapitalAssetLine();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedAddPurchasingItemCapitalAssetEvent("", purDocument, asset));
if (rulePassed) {
// get specific asset item and grab system as well and attach asset number
CapitalAssetSystem system = purDocument.getPurchasingCapitalAssetSystems().get(getSelectedLine(request));
asset = purDocument.getPurchasingCapitalAssetItems().get(0).getAndResetNewPurchasingItemCapitalAssetLine();
asset.setCapitalAssetSystemIdentifier(system.getCapitalAssetSystemIdentifier());
system.getItemCapitalAssets().add(asset);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward addItemCapitalAssetByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
// get specific asset item
PurchasingCapitalAssetItem assetItem = purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
ItemCapitalAsset asset = assetItem.getNewPurchasingItemCapitalAssetLine();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedAddPurchasingItemCapitalAssetEvent("", purDocument, asset));
if (rulePassed) {
// grab system as well and attach asset number
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
asset = assetItem.getAndResetNewPurchasingItemCapitalAssetLine();
asset.setCapitalAssetSystemIdentifier(system.getCapitalAssetSystemIdentifier());
system.getItemCapitalAssets().add(asset);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward deleteItemCapitalAssetByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
// get specific asset item
PurchasingCapitalAssetItem assetItem = purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
ItemCapitalAsset asset = assetItem.getNewPurchasingItemCapitalAssetLine();
boolean rulePassed = true; // SpringContext.getBean(KualiRuleService.class).applyRules(new
// AddPurchasingAccountsPayableItemEvent("", purDocument, item));
if (rulePassed) {
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String systemIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
String assetIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
PurchasingCapitalAssetSystemBase system = (PurchasingCapitalAssetSystemBase) purDocument.getPurchasingCapitalAssetSystems().get(Integer.parseInt(systemIndex));
system.getItemCapitalAssets().remove(Integer.parseInt(assetIndex));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward deleteItemCapitalAssetByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
// get specific asset item
PurchasingCapitalAssetItem assetItem = purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
ItemCapitalAsset asset = assetItem.getNewPurchasingItemCapitalAssetLine();
boolean rulePassed = true; // SpringContext.getBean(KualiRuleService.class).applyRules(new
// AddPurchasingAccountsPayableItemEvent("", purDocument, item));
if (rulePassed) {
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String assetIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
PurchasingCapitalAssetSystemBase system = (PurchasingCapitalAssetSystemBase) assetItem.getPurchasingCapitalAssetSystem();
system.getItemCapitalAssets().remove(Integer.parseInt(assetIndex));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward addCapitalAssetLocationByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
CapitalAssetLocation location = purchasingForm.getAndResetNewPurchasingCapitalAssetLocationLine();
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedAddPurchasingCapitalAssetLocationEvent("", purDocument, location));
rulePassed = rulePassed && SpringContext.getBean(PurchasingService.class).checkCapitalAssetLocation(location);
if (rulePassed) {
// get specific asset item and grab system as well and attach asset number
CapitalAssetSystem system = purDocument.getPurchasingCapitalAssetSystems().get(getSelectedLine(request));
location.setCapitalAssetSystemIdentifier(system.getCapitalAssetSystemIdentifier());
system.getCapitalAssetLocations().add(location);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward addCapitalAssetLocationByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
CapitalAssetLocation location = purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request)).getPurchasingCapitalAssetSystem().getNewPurchasingCapitalAssetLocationLine();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedAddPurchasingCapitalAssetLocationEvent("", purDocument, location));
if (rulePassed) {
// get specific asset item and grab system as well and attach asset location
PurchasingCapitalAssetItem assetItem = purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
location.setCapitalAssetSystemIdentifier(system.getCapitalAssetSystemIdentifier());
system.getCapitalAssetLocations().add(location);
// now reset the location as all the rules are passed successfully
purDocument.getPurchasingCapitalAssetItems().get(getSelectedLine(request)).getPurchasingCapitalAssetSystem().resetNewPurchasingCapitalAssetLocationLine();
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward deleteCapitalAssetLocationByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
CapitalAssetLocation location = purchasingForm.getNewPurchasingCapitalAssetLocationLine();
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
boolean rulePassed = true; // SpringContext.getBean(KualiRuleService.class).applyRules(new
// AddPurchasingAccountsPayableItemEvent("", purDocument, item));
if (rulePassed) {
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String systemIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
String locationIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
// get specific asset item and grab system as well and attach asset number
CapitalAssetSystem system = purDocument.getPurchasingCapitalAssetSystems().get(Integer.parseInt(systemIndex));
system.getCapitalAssetLocations().remove(Integer.parseInt(locationIndex));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward deleteCapitalAssetLocationByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
CapitalAssetLocation location = purchasingForm.getNewPurchasingCapitalAssetLocationLine();
PurchasingDocument purDocument = (PurchasingDocument) purchasingForm.getDocument();
boolean rulePassed = true; // SpringContext.getBean(KualiRuleService.class).applyRules(new
// AddPurchasingAccountsPayableItemEvent("", purDocument, item));
if (rulePassed) {
String fullParameter = (String) request.getAttribute(KFSConstants.METHOD_TO_CALL_ATTRIBUTE);
String assetItemIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
String locationIndex = StringUtils.substringBetween(fullParameter, KFSConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KFSConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
// get specific asset item and grab system as well and attach asset number
PurchasingCapitalAssetItem assetItem = purDocument.getPurchasingCapitalAssetItems().get(Integer.parseInt(assetItemIndex));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
system.getCapitalAssetLocations().remove(Integer.parseInt(locationIndex));
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward setupCAMSSystem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
SpringContext.getBean(PurchasingService.class).setupCapitalAssetSystem(document);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward selectSystem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
String errorPath = PurapConstants.CAPITAL_ASSET_TAB_ERRORS;
// validate entry is selected for each field
if (StringUtils.isEmpty(document.getCapitalAssetSystemTypeCode())) {
GlobalVariables.getMessageMap().putError(errorPath, KFSKeyConstants.ERROR_MISSING, "Capital Assets System Type Code");
}
else if (StringUtils.isEmpty(document.getCapitalAssetSystemStateCode())) {
GlobalVariables.getMessageMap().putError(errorPath, KFSKeyConstants.ERROR_MISSING, "Capital Assets System State Code");
}
else {
SpringContext.getBean(PurchasingService.class).setupCapitalAssetSystem(document);
SpringContext.getBean(PurchasingService.class).setupCapitalAssetItems(document);
if (!document.getPurchasingCapitalAssetItems().isEmpty()) {
saveDocumentNoValidationUsingClearErrorMap(document);
}
else {
// TODO: extract this and above strings to app resources
GlobalVariables.getMessageMap().putError(errorPath, KFSKeyConstants.ERROR_CUSTOM, "No items were found that met the requirements for Capital Asset data collection");
}
saveDocumentNoValidationUsingClearErrorMap(document);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
/**
* Sets the error map to a new, empty error map before calling saveDocumentNoValidation to save the document.
*
* @param document The purchase order document to be saved.
*/
protected void saveDocumentNoValidationUsingClearErrorMap(PurchasingDocument document) {
MessageMap errorHolder = GlobalVariables.getMessageMap();
GlobalVariables.setMessageMap(new MessageMap());
try {
SpringContext.getBean(PurapService.class).saveDocumentNoValidation(document);
}
finally {
GlobalVariables.setMessageMap(errorHolder);
}
}
public ActionForward changeSystem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
Object question = request.getParameter(PurapConstants.QUESTION_INDEX);
Object buttonClicked = request.getParameter(KFSConstants.QUESTION_CLICKED_BUTTON);
if (question == null) {
String questionText = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(PurapKeyConstants.PURCHASING_QUESTION_CONFIRM_CHANGE_SYSTEM);
return this.performQuestionWithoutInput(mapping, form, request, response, PurapConstants.CapitalAssetTabStrings.SYSTEM_SWITCHING_QUESTION, questionText, KFSConstants.CONFIRMATION_QUESTION, KFSConstants.ROUTE_METHOD, "0");
}
else if (ConfirmationQuestion.YES.equals(buttonClicked)) {
// Add a note if system change occurs when the document is a PO that is being amended.
if ((document instanceof PurchaseOrderDocument) && (PurapConstants.PurchaseOrderStatuses.APPDOC_CHANGE_IN_PROCESS.equals(document.getApplicationDocumentStatus()))) {
Integer poId = document.getPurapDocumentIdentifier();
PurchaseOrderDocument currentPO = SpringContext.getBean(PurchaseOrderService.class).getCurrentPurchaseOrder(poId);
String oldSystemTypeCode = "";
if (currentPO != null) {
oldSystemTypeCode = currentPO.getCapitalAssetSystemTypeCode();
}
CapitalAssetSystemType oldSystemType = new CapitalAssetSystemType();
oldSystemType.setCapitalAssetSystemTypeCode(oldSystemTypeCode);
Map<String, String> keys = SpringContext.getBean(PersistenceService.class).getPrimaryKeyFieldValues(oldSystemType);
oldSystemType = SpringContext.getBean(BusinessObjectService.class).findByPrimaryKey(CapitalAssetSystemType.class, keys);
String description = ((oldSystemType == null) ? "(NONE)" : oldSystemType.getCapitalAssetSystemTypeDescription());
if (document instanceof PurchaseOrderAmendmentDocument) {
String noteText = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(PurapKeyConstants.PURCHASE_ORDER_AMEND_MESSAGE_CHANGE_SYSTEM_TYPE);
noteText = StringUtils.replace(noteText, "{0}", description);
try {
Note systemTypeChangeNote = getDocumentService().createNoteFromDocument(document, noteText);
purchasingForm.setNewNote(systemTypeChangeNote);
insertBONote(mapping, purchasingForm, request, response);
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
}
if (form instanceof RequisitionForm) {
((RequisitionForm) form).resetNewPurchasingCapitalAssetLocationLine();
}
// remove capital assets from db
if (document instanceof PurchaseOrderAmendmentDocument) {
for (PurchasingCapitalAssetItem assetItem : document.getPurchasingCapitalAssetItems()) {
SpringContext.getBean(BusinessObjectService.class).delete((PersistableBusinessObject) assetItem);
}
}
document.clearCapitalAssetFields();
// saveDocumentNoValidationUsingClearErrorMap(document);
SpringContext.getBean(PurapService.class).saveDocumentNoValidation(document);
KNSGlobalVariables.getMessageList().add(PurapKeyConstants.PURCHASING_MESSAGE_SYSTEM_CHANGED);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward updateCamsView(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AttributedUpdateCamsViewPurapEvent(document));
if (rulePassed) {
SpringContext.getBean(PurchasingService.class).setupCapitalAssetItems(document);
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward setManufacturerFromVendorByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
String vendorName = document.getVendorName();
if (StringUtils.isEmpty(vendorName)) {
GlobalVariables.getMessageMap().putError(PurapConstants.CAPITAL_ASSET_TAB_ERRORS, PurapKeyConstants.ERROR_CAPITAL_ASSET_NO_VENDOR, (String[]) null);
}
else {
CapitalAssetSystem system = document.getPurchasingCapitalAssetSystems().get(getSelectedLine(request));
if (system != null) {
system.setCapitalAssetManufacturerName(vendorName);
}
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward setManufacturerFromVendorByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
String vendorName = document.getVendorName();
if (StringUtils.isEmpty(vendorName)) {
GlobalVariables.getMessageMap().putError(PurapConstants.CAPITAL_ASSET_TAB_ERRORS, PurapKeyConstants.ERROR_CAPITAL_ASSET_NO_VENDOR, (String[]) null);
}
else {
PurchasingCapitalAssetItem assetItem = document.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
if (system != null) {
system.setCapitalAssetManufacturerName(vendorName);
}
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward selectNotCurrentYearByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
CapitalAssetSystem system = document.getPurchasingCapitalAssetSystems().get(getSelectedLine(request));
if (system != null) {
system.setCapitalAssetNotReceivedCurrentFiscalYearIndicator(true);
system.setCapitalAssetTypeCode(SpringContext.getBean(PurchasingService.class).getDefaultAssetTypeCodeNotThisFiscalYear());
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward selectNotCurrentYearByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
PurchasingCapitalAssetItem assetItem = document.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
if (system != null) {
system.setCapitalAssetNotReceivedCurrentFiscalYearIndicator(true);
system.setCapitalAssetTypeCode(SpringContext.getBean(PurchasingService.class).getDefaultAssetTypeCodeNotThisFiscalYear());
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward clearNotCurrentYearByDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
CapitalAssetSystem system = document.getPurchasingCapitalAssetSystems().get(getSelectedLine(request));
if (system != null) {
system.setCapitalAssetNotReceivedCurrentFiscalYearIndicator(false);
system.setCapitalAssetTypeCode("");
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
public ActionForward clearNotCurrentYearByItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument document = (PurchasingDocument) purchasingForm.getDocument();
PurchasingCapitalAssetItem assetItem = document.getPurchasingCapitalAssetItems().get(getSelectedLine(request));
CapitalAssetSystem system = assetItem.getPurchasingCapitalAssetSystem();
if (system != null) {
system.setCapitalAssetNotReceivedCurrentFiscalYearIndicator(false);
system.setCapitalAssetTypeCode("");
}
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
@Override
public ActionForward calculate(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument purDoc = (PurchasingDocument) purchasingForm.getDocument();
boolean defaultUseTaxIndicatorValue = SpringContext.getBean(PurchasingService.class).getDefaultUseTaxIndicatorValue(purDoc);
SpringContext.getBean(PurapService.class).updateUseTaxIndicator(purDoc, defaultUseTaxIndicatorValue);
SpringContext.getBean(PurapService.class).calculateTax(purDoc);
// call prorateDiscountTradeIn
SpringContext.getBean(PurapService.class).prorateForTradeInAndFullOrderDiscount(purDoc);
// recalculate the amounts and percents on the accounting line.
SpringContext.getBean(PurapAccountingService.class).updateAccountAmounts(purDoc);
customCalculate(purDoc);
PurchasingFormBase formBase = (PurchasingFormBase) form;
formBase.setInitialZipCode(purDoc.getDeliveryPostalCode());
formBase.setCalculated(true);
purDoc.setCalculated(true);
KNSGlobalVariables.getMessageList().clear();
return super.calculate(mapping, form, request, response);
}
@Override
protected void loadDocument(KualiDocumentFormBase kualiDocumentFormBase) throws WorkflowException {
super.loadDocument(kualiDocumentFormBase);
PurchasingFormBase formBase = (PurchasingFormBase) kualiDocumentFormBase;
if (StringUtils.isEmpty(formBase.getInitialZipCode())) {
formBase.setInitialZipCode(((PurchasingDocument) formBase.getDocument()).getDeliveryPostalCode());
}
}
@Override
public ActionForward clearAllTaxes(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingAccountsPayableFormBase purchasingForm = (PurchasingAccountsPayableFormBase) form;
PurchasingDocument purDoc = (PurchasingDocument) purchasingForm.getDocument();
SpringContext.getBean(PurapService.class).clearAllTaxes(purDoc);
return super.clearAllTaxes(mapping, form, request, response);
}
/**
* Determine from request parameters if user is returning from capital asset building lookup. Parameter will start with either
* document.purchasingCapitalAssetItems or document.purchasingCapitalAssetSystems
*
* @param request
* @return
*/
protected String findBuildingCodeFromCapitalAssetBuildingLookup(HttpServletRequest request) {
Enumeration anEnum = request.getParameterNames();
while (anEnum.hasMoreElements()) {
String paramName = (String) anEnum.nextElement();
if (paramName.contains("urchasingCapitalAsset") && paramName.contains("buildingCode")) {
return paramName;
}
}
return "";
}
/**
* Overrides the superclass method so that it will also do proration for trade in and full order discount when the user clicks
* on the submit button.
*
* @see org.kuali.kfs.sys.web.struts.KualiAccountingDocumentActionBase#route(org.apache.struts.action.ActionMapping,
* org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
@Override
public ActionForward route(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDoc = (PurchasingDocument) purchasingForm.getDocument();
// if form is not yet calculated, return and prompt user to calculate
if (requiresCalculate(purchasingForm)) {
GlobalVariables.getMessageMap().putError(KFSConstants.DOCUMENT_ERRORS, PurapKeyConstants.ERROR_PURCHASING_REQUIRES_CALCULATE);
return mapping.findForward(KFSConstants.MAPPING_BASIC);
}
// call prorateDiscountTradeIn
SpringContext.getBean(PurapService.class).prorateForTradeInAndFullOrderDiscount(purDoc);
return super.route(mapping, form, request, response);
}
/**
* Overrides the superclass method so that it will also do proration for trade in and full order discount when the user clicks
* on the approve button.
*
* @see org.kuali.rice.kns.web.struts.action.KualiDocumentActionBase#approve(org.apache.struts.action.ActionMapping,
* org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
@Override
public ActionForward approve(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDoc = (PurchasingDocument) purchasingForm.getDocument();
// call prorateDiscountTradeIn
SpringContext.getBean(PurapService.class).prorateForTradeInAndFullOrderDiscount(purDoc);
return super.approve(mapping, form, request, response);
}
@Override
public ActionForward blanketApprove(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
PurchasingFormBase purchasingForm = (PurchasingFormBase) form;
PurchasingDocument purDoc = (PurchasingDocument) purchasingForm.getDocument();
// call prorateDiscountTradeIn
SpringContext.getBean(PurapService.class).prorateForTradeInAndFullOrderDiscount(purDoc);
return super.blanketApprove(mapping, form, request, response);
}
/**
* Checks if calculation is required. Currently it is required when it has not already been calculated and if the user can
* perform calculate
*
* @return true if calculation is required, false otherwise
*/
protected boolean requiresCalculate(PurchasingFormBase purForm) {
boolean requiresCalculate = true;
requiresCalculate = !purForm.isCalculated() && purForm.canUserCalculate();
return requiresCalculate;
}
}