/*
* 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.cam.batch.service.impl;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.kuali.kfs.gl.service.impl.StringHelper;
import org.kuali.kfs.module.cam.CamsConstants;
import org.kuali.kfs.module.cam.CamsPropertyConstants;
import org.kuali.kfs.module.cam.batch.service.AssetBarcodeInventoryLoadService;
import org.kuali.kfs.module.cam.businessobject.Asset;
import org.kuali.kfs.module.cam.businessobject.AssetLocation;
import org.kuali.kfs.module.cam.businessobject.BarcodeInventoryErrorDetail;
import org.kuali.kfs.module.cam.document.BarcodeInventoryErrorDocument;
import org.kuali.kfs.module.cam.document.validation.event.ValidateBarcodeInventoryEvent;
import org.kuali.kfs.module.cam.document.web.struts.AssetBarCodeInventoryInputFileForm;
import org.kuali.kfs.sys.KFSConstants;
import org.kuali.kfs.sys.KFSKeyConstants;
import org.kuali.rice.core.api.datetime.DateTimeService;
import org.kuali.rice.core.api.util.type.KualiDecimal;
import org.kuali.rice.coreservice.framework.parameter.ParameterService;
import org.kuali.rice.kew.api.KewApiConstants;
import org.kuali.rice.kew.api.document.WorkflowDocumentService;
import org.kuali.rice.kew.api.exception.WorkflowException;
import org.kuali.rice.kns.service.DataDictionaryService;
import org.kuali.rice.krad.bo.AdHocRoutePerson;
import org.kuali.rice.krad.bo.AdHocRouteRecipient;
import org.kuali.rice.krad.document.Document;
import org.kuali.rice.krad.service.BusinessObjectService;
import org.kuali.rice.krad.service.DocumentService;
import org.kuali.rice.krad.service.KualiRuleService;
import org.kuali.rice.krad.util.GlobalVariables;
/**
* Implementation of the AssetBarcodeInventoryLoadService interface. Handles loading, parsing, and storing of incoming barcode
* inventory files.
*/
public class AssetBarcodeInventoryLoadServiceImpl implements AssetBarcodeInventoryLoadService {
private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(AssetBarcodeInventoryLoadServiceImpl.class);
public static final String MESSAGE_NO_DOCUMENT_CREATED = "NO barcode inventory error document was created.";
public static final String DOCUMENTS_MSG = "The following barcode inventory error document were created";
public static final String TOTAL_RECORDS_UPLOADED_MSG = "Total records uploaded";
public static final String TOTAL_RECORDS_IN_ERROR_MSG = "Total records in error";
protected static final int MAX_NUMBER_OF_COLUMNS = 8;
protected static final String DOCUMENT_EXPLANATION = "BARCODE ERROR INVENTORY";
private BusinessObjectService businessObjectService;
private WorkflowDocumentService workflowDocumentService;
private DataDictionaryService dataDictionaryService;
private KualiRuleService kualiRuleService;
private DocumentService documentService;
private ParameterService parameterService;
private DateTimeService dateTimeService;
/**
* Determines whether or not the BCIE document has all its records corrected or deleted
*
* @param document
* @return boolean
*/
public boolean isFullyProcessed(Document document) {
BarcodeInventoryErrorDocument barcodeInventoryErrorDocument = (BarcodeInventoryErrorDocument)document;
boolean result = true;
List<BarcodeInventoryErrorDetail> barcodeInventoryErrorDetails = barcodeInventoryErrorDocument.getBarcodeInventoryErrorDetail();
BarcodeInventoryErrorDetail barcodeInventoryErrorDetail;
for (BarcodeInventoryErrorDetail detail : barcodeInventoryErrorDetails) {
if (detail.getErrorCorrectionStatusCode().equals(CamsConstants.BarCodeInventoryError.STATUS_CODE_ERROR)) {
result = false;
break;
}
}
return result;
}
/**
* @see org.kuali.kfs.module.cam.batch.service.AssetBarcodeInventoryLoadService#isCurrentUserInitiator(org.kuali.rice.krad.document.Document)
*/
public boolean isCurrentUserInitiator(Document document) {
if (document != null) {
return GlobalVariables.getUserSession().getPerson().getPrincipalId().equalsIgnoreCase(document.getDocumentHeader().getWorkflowDocument().getInitiatorPrincipalId());
}
return false;
}
/**
* @see org.kuali.module.cams.service.AssetBarcodeInventoryLoadService#isFileFormatValid(java.io.File)
*/
public boolean isFileFormatValid(File file) {
LOG.debug("isFileFormatValid(File file) - start");
String fileName = file.getName();
BufferedReader input = null;
// Getting the length of each field that needs to be validated
Integer campusTagNumberMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.CAMPUS_TAG_NUMBER);
Integer inventoryScannedCodeMaxLength = new Integer(1);
Integer InventoryDateMaxLength = dataDictionaryService.getAttributeMaxLength(BarcodeInventoryErrorDetail.class, CamsPropertyConstants.BarcodeInventory.INVENTORY_DATE);
Integer campusCodeMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.CAMPUS_CODE);
Integer buildingCodeMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.BUILDING_CODE);
Integer buildingRoomNumberMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.BUILDING_ROOM_NUMBER);
Integer buildingSubRoomNumberMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.BUILDING_SUB_ROOM_NUMBER);
Integer conditionCodeMaxLength = dataDictionaryService.getAttributeMaxLength(Asset.class, CamsPropertyConstants.Asset.CONDITION_CODE);
// Getting the label of each field from data dictionary.
String campusTagNumberLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.CAMPUS_TAG_NUMBER);
String inventoryScannedCodeLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.BarcodeInventory.UPLOAD_SCAN_INDICATOR);
String InventoryDateLabel = dataDictionaryService.getAttributeLabel(BarcodeInventoryErrorDetail.class, CamsPropertyConstants.BarcodeInventory.INVENTORY_DATE);
String campusCodeLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.CAMPUS_CODE);
String buildingCodeLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.BUILDING_CODE);
String buildingRoomNumberLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.BUILDING_ROOM_NUMBER);
String buildingSubRoomNumberLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.BUILDING_SUB_ROOM_NUMBER);
String conditionCodeLabel = dataDictionaryService.getAttributeLabel(Asset.class, CamsPropertyConstants.Asset.CONDITION_CODE);
try {
int recordCount = 0;
String errorMsg = "";
String errorMessage = "";
boolean proceed = true;
String lengthError = "exceeds maximum length";
input = new BufferedReader(new FileReader(file));
String line = null;
while ((line = input.readLine()) != null) {
recordCount++;
errorMsg = "";
line = StringUtils.remove(line, "\"");
String[] column = org.springframework.util.StringUtils.delimitedListToStringArray(line, ",");
if (MAX_NUMBER_OF_COLUMNS < column.length) {
// Error more columns that allowed. put it in the constants class.
errorMsg += " Barcode inventory file has record(s) with more than " + MAX_NUMBER_OF_COLUMNS + " columns\n";
proceed = false;
}
else if (MAX_NUMBER_OF_COLUMNS > column.length) {
errorMsg += " Barcode inventory file has record(s) with less than " + MAX_NUMBER_OF_COLUMNS + " columns\n";
proceed = false;
}
else {
// Validating length of each field
if (column[0].length() > campusTagNumberMaxLength.intValue()) {
errorMsg += ", " + campusTagNumberLabel;
}
if (column[1].length() > inventoryScannedCodeMaxLength.intValue()) {
errorMsg += ", " + inventoryScannedCodeLabel;
}
if (column[2].length() > InventoryDateMaxLength.intValue()) {
errorMsg += ", " + InventoryDateLabel;
}
if (column[3].length() > campusCodeMaxLength.intValue()) {
errorMsg += ", " + campusCodeLabel;
}
if (column[4].length() > buildingCodeMaxLength.intValue()) {
errorMsg += ", " + buildingCodeLabel;
}
if (column[5].length() > buildingRoomNumberMaxLength.intValue()) {
errorMsg += ", " + buildingRoomNumberLabel;
}
if (column[6].length() > buildingSubRoomNumberMaxLength.intValue()) {
errorMsg += ", " + buildingSubRoomNumberLabel;
}
if (column[7].length() > conditionCodeMaxLength.intValue()) {
errorMsg += ", " + conditionCodeLabel;
}
if (!StringUtils.isBlank(errorMsg)) {
errorMsg += " " + lengthError;
}
// Validating other than the length of the fields
if (!column[1].equals(CamsConstants.BarCodeInventory.BCI_SCANED_INTO_DEVICE) && !column[1].equals(CamsConstants.BarCodeInventory.BCI_MANUALLY_KEYED_CODE)) {
errorMsg += ", " + inventoryScannedCodeLabel + " is invalid";
}
// validate date
if(!validateDate(column[2])) {
errorMsg += ", " + InventoryDateLabel + " is invalid";
}
}
if (!StringUtils.isBlank(errorMsg)) {
errorMsg = "Error on record number " + recordCount + ": " + errorMsg.substring(2) + "\n";
GlobalVariables.getMessageMap().putError(KFSConstants.GLOBAL_ERRORS, KFSKeyConstants.ERROR_CUSTOM, errorMsg);
errorMessage += errorMsg;
LOG.error(errorMsg);
}
if (!proceed)
break;
}
if (!StringUtils.isBlank(errorMessage)) {
return false;
}
return true;
}
catch (FileNotFoundException e1) {
LOG.error("file to parse not found " + fileName, e1);
throw new RuntimeException("Cannot find the file requested to be parsed " + fileName + " " + e1.getMessage(), e1);
}
catch (Exception e) {
LOG.error("Error running file validation - File: " + fileName, e);
throw new IllegalArgumentException("Error running file validation - File: " + fileName);
}
finally {
LOG.debug("isFileFormatValid(File file) - end");
try {
if (input != null) {
input.close();
}
}
catch (IOException ex) {
LOG.error("isFileFormatValid() error closing file.", ex);
}
}
}
/**
* @see org.kuali.module.cams.service.AssetBarCodeInventoryLoadService#processFile(java.io.File)
*/
public boolean processFile(File file, AssetBarCodeInventoryInputFileForm form) {
LOG.debug("processFile(File file) - start");
// Removing *.done files that are created automatically by the framework.
this.removeDoneFile(file);
BufferedReader input = null;
String fileName = file.getName();
String day;
String month;
String year;
String hours;
String minutes;
String seconds;
boolean isValid = true;
SimpleDateFormat formatter = new SimpleDateFormat(CamsConstants.DateFormats.MONTH_DAY_YEAR + " " + CamsConstants.DateFormats.MILITARY_TIME, Locale.US);
formatter.setLenient(false);
BarcodeInventoryErrorDetail barcodeInventoryErrorDetail;
List<BarcodeInventoryErrorDetail> barcodeInventoryErrorDetails = new ArrayList<BarcodeInventoryErrorDetail>();
List<BarcodeInventoryErrorDocument> barcodeInventoryErrorDocuments = new ArrayList<BarcodeInventoryErrorDocument>();
try {
Long ln = new Long(1);
input = new BufferedReader(new FileReader(file));
String line = null;
while ((line = input.readLine()) != null) {
line = StringUtils.remove(line, "\"");
String[] lineStrings = org.springframework.util.StringUtils.delimitedListToStringArray(line, ",");
// Parsing date so it can be validated.
lineStrings[2] = StringUtils.rightPad(lineStrings[2].trim(), 14, "0");
day = lineStrings[2].substring(0, 2);
month = lineStrings[2].substring(2, 4);
year = lineStrings[2].substring(4, 8);
hours = lineStrings[2].substring(8, 10);
minutes = lineStrings[2].substring(10, 12);
seconds = lineStrings[2].substring(12);
String stringDate = month + "/" + day + "/" + year + " " + hours + ":" + minutes + ":" + seconds;
Timestamp timestamp = null;
// If date has invalid format set its value to null
try {
timestamp = new Timestamp(formatter.parse(stringDate).getTime());
}
catch (Exception e) {
}
// Its set to null because for some reason java parses "00000000000000" as 0002-11-30
if (lineStrings[2].equals(StringUtils.repeat("0", 14))) {
timestamp = null;
}
barcodeInventoryErrorDetail = new BarcodeInventoryErrorDetail();
barcodeInventoryErrorDetail.setUploadRowNumber(ln);
barcodeInventoryErrorDetail.setAssetTagNumber(lineStrings[0].trim());
barcodeInventoryErrorDetail.setUploadScanIndicator(lineStrings[1].equals(CamsConstants.BarCodeInventory.BCI_SCANED_INTO_DEVICE));
barcodeInventoryErrorDetail.setUploadScanTimestamp(timestamp);
barcodeInventoryErrorDetail.setCampusCode(lineStrings[3].trim().toUpperCase());
barcodeInventoryErrorDetail.setBuildingCode(lineStrings[4].trim().toUpperCase());
barcodeInventoryErrorDetail.setBuildingRoomNumber(lineStrings[5].trim().toUpperCase());
barcodeInventoryErrorDetail.setBuildingSubRoomNumber(lineStrings[6].trim().toUpperCase());
barcodeInventoryErrorDetail.setAssetConditionCode(lineStrings[7].trim().toUpperCase());
barcodeInventoryErrorDetail.setErrorCorrectionStatusCode(CamsConstants.BarCodeInventoryError.STATUS_CODE_ERROR);
barcodeInventoryErrorDetail.setCorrectorUniversalIdentifier(GlobalVariables.getUserSession().getPerson().getPrincipalId());
barcodeInventoryErrorDetails.add(barcodeInventoryErrorDetail);
ln++;
}
processBarcodeInventory(barcodeInventoryErrorDetails, form);
return true;
}
catch (FileNotFoundException e1) {
LOG.error("file to parse not found " + fileName, e1);
throw new RuntimeException("Cannot find the file requested to be parsed " + fileName + " " + e1.getMessage(), e1);
}
catch (Exception ex) {
LOG.error("Error reading file", ex);
throw new IllegalArgumentException("Error reading file: " + ex.getMessage(), ex);
}
finally {
LOG.debug("processFile(File file) - End");
try {
if (input != null) {
input.close();
}
}
catch (IOException ex) {
LOG.error("loadFlatFile() error closing file.", ex);
}
}
}
/**
* This method removes the *.done files. If not deleted, then the program will display the name of the file in a puldown menu
* with a label of ready for process.
*
* @param file
*/
protected void removeDoneFile(File file) {
String filePath = file.getAbsolutePath();
File doneFile = new File(StringUtils.substringBeforeLast(filePath, ".") + ".done");
if (doneFile.exists()) {
doneFile.delete();
}
}
/**
* This method invokes the rules in order to validate each records of the barcode file and invokes the method that updates the
* asset table with the records that passes the rules validation
*
* @param barcodeInventoryErrorDetails
*/
protected void processBarcodeInventory(List<BarcodeInventoryErrorDetail> barcodeInventoryErrorDetails, AssetBarCodeInventoryInputFileForm form) throws Exception {
Long lineNumber = new Long(0);
boolean docCreated = false;
int errorRecCount = 0;
int totalRecCount = 0;
BarcodeInventoryErrorDocument barcodeInventoryErrorDocument = createInvalidBarcodeInventoryDocument(barcodeInventoryErrorDetails, form.getUploadDescription());
// apply rules for the new cash control detail
kualiRuleService.applyRules(new ValidateBarcodeInventoryEvent("", barcodeInventoryErrorDocument, true));
List<BarcodeInventoryErrorDetail> tmpBarcodeInventoryErrorDetails = new ArrayList<BarcodeInventoryErrorDetail>();
for (BarcodeInventoryErrorDetail barcodeInventoryErrorDetail : barcodeInventoryErrorDetails) {
totalRecCount++;
// if no error found, then update asset table.
if (!barcodeInventoryErrorDetail.getErrorCorrectionStatusCode().equals(CamsConstants.BarCodeInventoryError.STATUS_CODE_ERROR)) {
this.updateAssetInformation(barcodeInventoryErrorDetail,true);
}
else {
errorRecCount++;
lineNumber++;
// Assigning the row number to each invalid BCIE record
barcodeInventoryErrorDetail.setUploadRowNumber(lineNumber);
// Storing in temp collection the invalid BCIE records.
tmpBarcodeInventoryErrorDetails.add(barcodeInventoryErrorDetail);
}
}
// *********************************************************************
// Storing the invalid barcode inventory records.
// *********************************************************************
String documentsCreated = "";
if (!tmpBarcodeInventoryErrorDetails.isEmpty()) {
documentsCreated = this.createBarcodeInventoryErrorDocuments(tmpBarcodeInventoryErrorDetails, barcodeInventoryErrorDocument, form);
docCreated = true;
}
if (!docCreated) {
form.getMessages().add(MESSAGE_NO_DOCUMENT_CREATED);
}
else {
// Adding the list of documents that were created in the message list
form.getMessages().add(DOCUMENTS_MSG + ": " + documentsCreated.substring(2));
}
form.getMessages().add(TOTAL_RECORDS_UPLOADED_MSG + ": " + StringUtils.rightPad(Integer.toString(totalRecCount), 5, " "));
form.getMessages().add(TOTAL_RECORDS_IN_ERROR_MSG + ": " + StringUtils.rightPad(Integer.toString(errorRecCount), 5, " "));
}
/**
* This method...
*
* @param bcies
* @param barcodeInventoryErrorDocument
*/
protected String createBarcodeInventoryErrorDocuments(List<BarcodeInventoryErrorDetail> bcies, BarcodeInventoryErrorDocument barcodeInventoryErrorDocument, AssetBarCodeInventoryInputFileForm form) {
List<BarcodeInventoryErrorDetail> barcodeInventoryErrorDetails = new ArrayList<BarcodeInventoryErrorDetail>();
boolean isFirstDocument = true;
int ln = 0;
int bcieCount = 0;
String documentsCreated = "";
int maxNumberRecordsPerDocument = 300;
try {
if (parameterService.parameterExists(BarcodeInventoryErrorDocument.class, CamsConstants.Parameters.MAX_NUMBER_OF_RECORDS_PER_DOCUMENT)) {
maxNumberRecordsPerDocument = new Integer(parameterService.getParameterValueAsString(BarcodeInventoryErrorDocument.class, CamsConstants.Parameters.MAX_NUMBER_OF_RECORDS_PER_DOCUMENT)).intValue();
}
while (true) {
if ((ln > maxNumberRecordsPerDocument) || (bcieCount >= bcies.size())) {
// This if was added in order to not waste the document already created and not create a new one.
if (!isFirstDocument) {
barcodeInventoryErrorDocument = createInvalidBarcodeInventoryDocument(barcodeInventoryErrorDetails, form.getUploadDescription());
}
documentsCreated += ", " + barcodeInventoryErrorDocument.getDocumentNumber();
barcodeInventoryErrorDocument.setBarcodeInventoryErrorDetail(barcodeInventoryErrorDetails);
saveInvalidBarcodeInventoryDocument(barcodeInventoryErrorDocument);
barcodeInventoryErrorDetails = new ArrayList<BarcodeInventoryErrorDetail>();
if (bcieCount >= bcies.size())
break;
ln = 0;
isFirstDocument = false;
}
BarcodeInventoryErrorDetail barcodeInventoryErrorDetail =bcies.get(bcieCount);
barcodeInventoryErrorDetail.setUploadRowNumber(Long.valueOf(ln+1));
barcodeInventoryErrorDetails.add(barcodeInventoryErrorDetail);
ln++;
bcieCount++;
}
}
catch (Exception e) {
LOG.error("Error creating BCIE documents", e);
throw new IllegalArgumentException("Error creating BCIE documents: " + e.getMessage(), e);
}
return documentsCreated;
}
/**
* This method updates the asset information particularly the building code, bulding room, building subrool, campus code, and
* condition code
*
* @param barcodeInventoryErrorDetail
*/
public void updateAssetInformation(BarcodeInventoryErrorDetail barcodeInventoryErrorDetail, boolean updateWithDateAssetWasScanned) {
Map<String, String> fieldValues = new HashMap<String, String>();
fieldValues.put(CamsPropertyConstants.Asset.CAMPUS_TAG_NUMBER, barcodeInventoryErrorDetail.getAssetTagNumber());
Asset asset = ((List<Asset>) businessObjectService.findMatching(Asset.class, fieldValues)).get(0);
asset.setInventoryScannedCode((barcodeInventoryErrorDetail.isUploadScanIndicator() ? CamsConstants.BarCodeInventory.BCI_SCANED_INTO_DEVICE : CamsConstants.BarCodeInventory.BCI_MANUALLY_KEYED_CODE));
asset.setBuildingCode(barcodeInventoryErrorDetail.getBuildingCode());
asset.setBuildingRoomNumber(barcodeInventoryErrorDetail.getBuildingRoomNumber());
asset.setBuildingSubRoomNumber(barcodeInventoryErrorDetail.getBuildingSubRoomNumber());
asset.setCampusCode(barcodeInventoryErrorDetail.getCampusCode());
asset.setConditionCode(barcodeInventoryErrorDetail.getAssetConditionCode());
// set building code and room number to null if they are empty string, to avoid FK violation exception
if (StringUtils.isEmpty(asset.getBuildingCode())) {
asset.setBuildingCode(null);
asset.setBuilding(null);
}
if (StringUtils.isEmpty(asset.getBuildingRoomNumber())) {
asset.setBuildingRoomNumber(null);
asset.setBuildingRoom(null);
}
if (updateWithDateAssetWasScanned) {
asset.setLastInventoryDate(barcodeInventoryErrorDetail.getUploadScanTimestamp());
} else {
asset.setLastInventoryDate(new Timestamp(dateTimeService.getCurrentSqlDate().getTime()));
}
// Purposefully deleting off-campus locations when loading locations via barcode scanning.
List<AssetLocation> assetLocations = asset.getAssetLocations();
for (AssetLocation assetLocation : assetLocations) {
if(CamsConstants.AssetLocationTypeCode.OFF_CAMPUS.equals(assetLocation.getAssetLocationTypeCode())) {
assetLocations.remove(assetLocation);
break;
}
}
// Updating asset information
businessObjectService.save(asset);
}
/**
* This method creates a transaction document with the invalid barcode inventory records
*
* @param barcodeInventoryErrorDetails
* @return BarcodeInventoryErrorDocument
*/
protected BarcodeInventoryErrorDocument createInvalidBarcodeInventoryDocument(List<BarcodeInventoryErrorDetail> barcodeInventoryErrorDetails, String uploadDescription) throws WorkflowException {
BarcodeInventoryErrorDocument document = (BarcodeInventoryErrorDocument) documentService.getNewDocument(BarcodeInventoryErrorDocument.class);
document.getDocumentHeader().setExplanation(DOCUMENT_EXPLANATION);
document.getFinancialSystemDocumentHeader().setFinancialDocumentTotalAmount(KualiDecimal.ZERO);
document.getDocumentHeader().setDocumentDescription(uploadDescription);
document.setUploaderUniversalIdentifier(GlobalVariables.getUserSession().getPerson().getPrincipalId());
document.setBarcodeInventoryErrorDetail(barcodeInventoryErrorDetails);
return document;
}
/**
* saves the barcode inventory document
*
* @param document
*/
protected void saveInvalidBarcodeInventoryDocument(BarcodeInventoryErrorDocument document) {
try {
// The errors are being deleted because, when the document services finds any error then, changes are not saved.
GlobalVariables.clear();
// no adhoc recipient need to add when submit doc. doc will route to the doc uploader, i.e. initiator automtically.
List<AdHocRouteRecipient> adHocRouteRecipients = new ArrayList<AdHocRouteRecipient>();
documentService.routeDocument(document, "Routed Update Barcode Inventory Document", adHocRouteRecipients);
}
catch (Exception e) {
LOG.error("Error persisting document # " + document.getDocumentHeader().getDocumentNumber() + " " + e.getMessage(), e);
throw new RuntimeException("Error persisting document # " + document.getDocumentHeader().getDocumentNumber() + " " + e.getMessage(), e);
}
}
/**
* This method builds a recipient for Approval.
*
* @param userId
* @return
*/
protected AdHocRouteRecipient buildApprovePersonRecipient(String userId) {
AdHocRouteRecipient adHocRouteRecipient = new AdHocRoutePerson();
adHocRouteRecipient.setActionRequested(KewApiConstants.ACTION_REQUEST_APPROVE_REQ);
adHocRouteRecipient.setId(userId);
return adHocRouteRecipient;
}
private boolean validateDate(String date) {
// Parsing date so it can be validated.
boolean valid = true;
if(StringHelper.isEmpty(date)) {
valid = false;
}
else {
SimpleDateFormat formatter = new SimpleDateFormat(CamsConstants.DateFormats.MONTH_DAY_YEAR + " " + CamsConstants.DateFormats.STANDARD_TIME, Locale.US);
date = StringUtils.rightPad(date.trim(), 14, "0");
String day = date.substring(0, 2);
String month = date.substring(2, 4);
String year = date.substring(4, 8);
String hours = date.substring(8, 10);
String minutes = date.substring(10, 12);
String seconds = date.substring(12);
String stringDate = month + "/" + day + "/" + year + " " + hours + ":" + minutes + ":" + seconds;
Timestamp timestamp = null;
// If date has invalid format set its value to null
try {
timestamp = new Timestamp(formatter.parse(stringDate).getTime());
}
catch (Exception e) {
valid = false;
}
}
return valid;
}
public void setBusinessObjectService(BusinessObjectService businessObjectService) {
this.businessObjectService = businessObjectService;
}
public void setDataDictionaryService(DataDictionaryService dataDictionaryService) {
this.dataDictionaryService = dataDictionaryService;
}
public void setWorkflowDocumentService(WorkflowDocumentService workflowDocumentService) {
this.workflowDocumentService = workflowDocumentService;
}
public void setKualiRuleService(KualiRuleService ruleService) {
this.kualiRuleService = ruleService;
}
public void setDocumentService(DocumentService documentService) {
this.documentService = documentService;
}
public ParameterService getParameterService() {
return parameterService;
}
public void setParameterService(ParameterService parameterService) {
this.parameterService = parameterService;
}
public void setDateTimeService(DateTimeService dateTimeService) {
this.dateTimeService = dateTimeService;
}
}