/*
* 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.gl.batch.service.impl;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.kuali.kfs.gl.batch.dataaccess.LedgerEntryBalanceCachingDao;
import org.kuali.kfs.gl.batch.service.BalancingService;
import org.kuali.kfs.gl.batch.service.PosterService;
import org.kuali.kfs.gl.businessobject.Balance;
import org.kuali.kfs.gl.businessobject.Entry;
import org.kuali.kfs.gl.businessobject.OriginEntryInformation;
import org.kuali.kfs.gl.dataaccess.LedgerBalanceBalancingDao;
import org.kuali.kfs.gl.dataaccess.LedgerBalanceHistoryBalancingDao;
import org.kuali.kfs.gl.dataaccess.LedgerBalancingDao;
import org.kuali.kfs.gl.dataaccess.LedgerEntryBalancingDao;
import org.kuali.kfs.gl.dataaccess.LedgerEntryHistoryBalancingDao;
import org.kuali.kfs.sys.KFSKeyConstants;
import org.kuali.kfs.sys.KFSPropertyConstants;
import org.kuali.kfs.sys.Message;
import org.kuali.kfs.sys.service.ReportWriterService;
import org.kuali.kfs.sys.service.UniversityDateService;
import org.kuali.rice.core.api.config.property.ConfigurationService;
import org.kuali.rice.core.api.datetime.DateTimeService;
import org.kuali.rice.coreservice.framework.parameter.ParameterService;
import org.kuali.rice.krad.bo.PersistableBusinessObjectBase;
import org.kuali.rice.krad.service.BusinessObjectService;
import org.kuali.rice.krad.service.PersistenceStructureService;
import org.kuali.rice.krad.util.ObjectUtils;
import org.springframework.transaction.annotation.Transactional;
/**
* Base service implementation for BalancingService. Useful for generic implementation of common code between la`bor and GL
* balancing.
*/
@Transactional
public abstract class BalancingServiceBaseImpl<T extends Entry, S extends Balance> implements BalancingService {
private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(BalancingServiceBaseImpl.class);
// Used to enable us to do generic general ledger or labor balancing
protected Class<T> entryHistoryPersistentClass;
protected Class<S> balanceHistoryPersistentClass;
protected ParameterService parameterService;
protected PersistenceStructureService persistenceStructureService;
protected ConfigurationService kualiConfigurationService;
protected BusinessObjectService businessObjectService;
protected DateTimeService dateTimeService;
protected UniversityDateService universityDateService;
protected LedgerBalancingDao ledgerBalancingDao;
protected LedgerEntryBalancingDao ledgerEntryBalancingDao;
protected LedgerEntryBalanceCachingDao ledgerEntryBalanceCachingDao;
protected LedgerBalanceBalancingDao ledgerBalanceBalancingDao;
protected LedgerBalanceHistoryBalancingDao ledgerBalanceHistoryBalancingDao;
protected LedgerEntryHistoryBalancingDao ledgerEntryHistoryBalancingDao;
protected ReportWriterService reportWriterService;
protected String batchFileDirectoryName;
/**
* Constructs a BalancingServiceBaseImpl.java. The generics are expected to be of type Balance and Entry respectively.
*/
public BalancingServiceBaseImpl() {
super();
this.entryHistoryPersistentClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
this.balanceHistoryPersistentClass = (Class<S>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
}
/**
* @see org.kuali.kfs.gl.batch.service.BalancingService#runBalancing()
*/
@Override
public boolean runBalancing() {
// Prepare date constants used throughout the process
Integer currentUniversityFiscalYear = universityDateService.getCurrentFiscalYear();
int startUniversityFiscalYear = currentUniversityFiscalYear - this.getPastFiscalYearsToConsider();
LOG.debug("Checking files required for balancing process are present.");
if (!this.isFilesReady()) {
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.ERROR_BATCH_BALANCING_FILES));
return false;
}
LOG.debug("Checking data required for balancing process is present.");
boolean historyTablesPopulated = false;
// Following does not check for custom data (AccountBalance & Encumbrance) present. Should be OK since it can't exist
// without entry and balance data.
if (this.getHistoryCount(null, entryHistoryPersistentClass) == 0 || this.getHistoryCount(null, balanceHistoryPersistentClass) == 0) {
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_DATA_INSERT), entryHistoryPersistentClass.getSimpleName(), balanceHistoryPersistentClass.getSimpleName());
reportWriterService.writeNewLines(1);
ledgerBalancingDao.populateLedgerEntryHistory(startUniversityFiscalYear);
ledgerBalancingDao.populateLedgerBalanceHistory(startUniversityFiscalYear);
this.customPopulateHistoryTables(startUniversityFiscalYear);
historyTablesPopulated = true;
}
LOG.debug("Checking if obsolete historic data present. Deleting if yes.");
// This only happens on the first accounting cycle after universityDateService.getFirstDateOfFiscalYear(currentYear) but
// since we are not
// guaranteed a batch cycle on each day there isn't a generic way of only running this once during the year.
boolean obsoleteUniversityFiscalYearDeleted = false;
int obsoleteUniversityFiscalYear = startUniversityFiscalYear - 1;
if (this.getHistoryCount(obsoleteUniversityFiscalYear, entryHistoryPersistentClass) != 0 || this.getHistoryCount(obsoleteUniversityFiscalYear, balanceHistoryPersistentClass) != 0 || this.doesCustomHistoryExist(obsoleteUniversityFiscalYear)) {
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_OBSOLETE_FISCAL_YEAR_DATA_DELETED), entryHistoryPersistentClass.getSimpleName(), balanceHistoryPersistentClass.getSimpleName(), obsoleteUniversityFiscalYear);
reportWriterService.writeNewLines(1);
this.deleteHistory(obsoleteUniversityFiscalYear, entryHistoryPersistentClass);
this.deleteHistory(obsoleteUniversityFiscalYear, balanceHistoryPersistentClass);
this.deleteCustomHistory(obsoleteUniversityFiscalYear);
obsoleteUniversityFiscalYearDeleted = true;
}
// We only do update step if history has not been populated. If it has we can't run the update cycle because they were
// already picked up
int updateRecordsIgnored = 0;
if (!historyTablesPopulated) {
LOG.debug("Getting postable records and save them to history tables.");
updateRecordsIgnored = this.updateHistoriesHelper(PosterService.MODE_ENTRIES, startUniversityFiscalYear, this.getPosterInputFile(), this.getPosterErrorOutputFile());
updateRecordsIgnored += this.updateHistoriesHelper(PosterService.MODE_REVERSAL, startUniversityFiscalYear, this.getReversalInputFile(), this.getReversalErrorOutputFile());
updateRecordsIgnored += this.updateHistoriesHelper(PosterService.MODE_ICR, startUniversityFiscalYear, this.getICRInputFile(), this.getICRErrorOutputFile());
updateRecordsIgnored += this.updateHistoriesHelper(PosterService.MODE_ICRENCMB, startUniversityFiscalYear, this.getICREncumbranceInputFile(), this.getICREncumbranceErrorOutputFile());
}
LOG.debug("Comparing entry history table with the PRD counterpart.");
int countEntryComparisionFailure = this.compareEntryHistory();
if (countEntryComparisionFailure != 0) {
reportWriterService.writeNewLines(1);
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_FAILURE_COUNT), entryHistoryPersistentClass.getSimpleName(), countEntryComparisionFailure, this.getComparisonFailuresToPrintPerReport());
}
LOG.debug("Comparing balance history table with the PRD counterpart.");
int countBalanceComparisionFailure = this.compareBalanceHistory();
if (countBalanceComparisionFailure != 0) {
reportWriterService.writeNewLines(1);
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_FAILURE_COUNT), balanceHistoryPersistentClass.getSimpleName(), countBalanceComparisionFailure, this.getComparisonFailuresToPrintPerReport());
}
LOG.debug("Comparing custom, if any, history table with the PRD counterpart.");
Map<String, Integer> countCustomComparisionFailures = this.customCompareHistory();
if (!historyTablesPopulated) {
reportWriterService.writeNewLines(1);
reportWriterService.writeFormattedMessageLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_FILE_LISTING), this.getFilenames());
}
LOG.debug("Writing statistics section");
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_FISCAL_YEARS_INCLUDED), ledgerBalanceHistoryBalancingDao.findDistinctFiscalYears());
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_HISTORY_TABLES_INITIALIZED), historyTablesPopulated ? "Yes" : "No");
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_OBSOLETE_DELETED), obsoleteUniversityFiscalYearDeleted ? "Yes (" + obsoleteUniversityFiscalYear + ")" : "No");
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_UPDATED_SKIPPED), updateRecordsIgnored);
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_COMPARISION_FAILURE), this.getShortTableLabel(entryHistoryPersistentClass.getSimpleName()), "(" + entryHistoryPersistentClass.getSimpleName() + ")", countEntryComparisionFailure);
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_COMPARISION_FAILURE), this.getShortTableLabel(balanceHistoryPersistentClass.getSimpleName()), "(" + balanceHistoryPersistentClass.getSimpleName() + ")", countBalanceComparisionFailure);
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_ENTRY_SUM_ROW_COUNT_HISTORY), this.getShortTableLabel(entryHistoryPersistentClass.getSimpleName()), "(" + entryHistoryPersistentClass.getSimpleName() + ")", ledgerEntryHistoryBalancingDao.findSumRowCountGreaterOrEqualThan(startUniversityFiscalYear));
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_ENTRY_ROW_COUNT_PRODUCTION), this.getShortTableLabel((Entry.class).getSimpleName()), ledgerEntryBalancingDao.findCountGreaterOrEqualThan(startUniversityFiscalYear));
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_BALANCE_ROW_COUNT_HISTORY), this.getShortTableLabel(balanceHistoryPersistentClass.getSimpleName()), "(" + balanceHistoryPersistentClass.getSimpleName() + ")", this.getHistoryCount(null, balanceHistoryPersistentClass));
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_BALANCE_ROW_COUNT_PRODUCTION), this.getShortTableLabel((Balance.class).getSimpleName()), ledgerBalanceBalancingDao.findCountGreaterOrEqualThan(startUniversityFiscalYear));
if (ObjectUtils.isNotNull(countCustomComparisionFailures)) {
for (Iterator<String> names = countCustomComparisionFailures.keySet().iterator(); names.hasNext();) {
String name = names.next();
int count = countCustomComparisionFailures.get(name);
reportWriterService.writeStatisticLine(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.REPORT_COMPARISION_FAILURE), this.getShortTableLabel(name), "(" + name + ")", count);
}
}
this.customPrintRowCountHistory(startUniversityFiscalYear);
return true;
}
/**
* @return if the files required for processing of this job are present and readable.
*/
protected boolean isFilesReady() {
File inputFile = this.getPosterInputFile();
File errorFile = this.getPosterErrorOutputFile();
return inputFile != null && errorFile != null && inputFile.exists() && errorFile.exists() && inputFile.canRead() && errorFile.canRead();
}
/**
* Deletes data for the given fiscal year of entries from persistentClass.
*
* @param universityFiscalYear the given university fiscal year
* @param persistentClass table for which to delete the history
*/
protected void deleteHistory(Integer universityFiscalYear, Class<? extends PersistableBusinessObjectBase> persistentClass) {
Map<String, Object> fieldValues = new HashMap<String, Object>();
fieldValues.put(KFSPropertyConstants.UNIVERSITY_FISCAL_YEAR, universityFiscalYear);
businessObjectService.deleteMatching(persistentClass, fieldValues);
}
/**
* Gets count for given fiscal year of entries from persistentClass.
*
* @param fiscalYear parameter may be null which will get count for all years
* @param persistentClass table for which to get the count
* @return count
*/
protected int getHistoryCount(Integer fiscalYear, Class<? extends PersistableBusinessObjectBase> persistentClass) {
Map<String, String> keyMap = new HashMap<String, String>();
if (fiscalYear != null) {
keyMap.put(KFSPropertyConstants.UNIVERSITY_FISCAL_YEAR, fiscalYear.toString());
}
return businessObjectService.countMatching(persistentClass, keyMap);
}
/**
* This is a helper method that wraps parsing poster entries for updateEntryHistory and updateBalanceHistory.
*
* @param startUniversityFiscalYear fiscal year for which to accept the earlier parsed lines from the input file
* @return indicated whether records where ignored due to being older then startUniversityFiscalYear
*/
protected int updateHistoriesHelper(Integer postMode, Integer startUniversityFiscalYear, File inputFile, File errorFile) {
int ignoredRecordsFound = 0;
int lineNumber = 0;
if (inputFile == null || errorFile == null) {
return 0;
}
try {
FileReader posterInputFileReader = new FileReader(inputFile);
BufferedReader posterInputBufferedReader = new BufferedReader(posterInputFileReader);
FileReader posterErrorFileReader = new FileReader(errorFile);
BufferedReader posterErrorBufferedReader = new BufferedReader(posterErrorFileReader);
// Reading input and error lines in tandem. Eliminating input lines if they were a line in error.
String currentInputLine = posterInputBufferedReader.readLine();
String currentErrorLine = posterErrorBufferedReader.readLine();
while (currentInputLine != null) {
lineNumber++;
if (!StringUtils.isEmpty(currentInputLine) && !StringUtils.isBlank(currentInputLine.trim())) {
if (currentInputLine.equals(currentErrorLine)) {
// Skip it, it's in error. Increment to next error line
currentErrorLine = posterErrorBufferedReader.readLine();
}
else {
// Line is good, parse it via delegation
OriginEntryInformation originEntry = this.getOriginEntry(currentInputLine, lineNumber);
if (originEntry.getUniversityFiscalYear() >= startUniversityFiscalYear) {
// Line is in acceptable FY range, update history tables
this.updateEntryHistory(postMode, originEntry);
this.updateBalanceHistory(postMode, originEntry);
this.updateCustomHistory(postMode, originEntry);
}
else {
// Outside of trackable FY range. Log as being a failed line
ignoredRecordsFound++;
reportWriterService.writeError(originEntry, new Message(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.MESSAGE_BATCH_BALANCING_RECORD_BEFORE_FISCAL_YEAR), Message.TYPE_WARNING, startUniversityFiscalYear));
}
}
}
currentInputLine = posterInputBufferedReader.readLine();
}
posterInputFileReader.close();
posterInputBufferedReader.close();
posterErrorFileReader.close();
posterErrorBufferedReader.close();
}
catch (Exception e) {
LOG.fatal(String.format(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.ERROR_BATCH_BALANCING_UNKNOWN_FAILURE), e.getMessage(), lineNumber), e);
reportWriterService.writeFormattedMessageLine(String.format(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.ERROR_BATCH_BALANCING_UNKNOWN_FAILURE), e.getMessage(), lineNumber));
throw new RuntimeException(String.format(kualiConfigurationService.getPropertyValueAsString(KFSKeyConstants.Balancing.ERROR_BATCH_BALANCING_UNKNOWN_FAILURE), e.getMessage(), lineNumber), e);
}
return ignoredRecordsFound;
}
abstract protected Integer compareBalanceHistory();
abstract protected Integer compareEntryHistory();
/**
*
* @return
*/
protected int getFiscalYear(){
return universityDateService.getCurrentFiscalYear()-getPastFiscalYearsToConsider();
}
/**
* Possible override if sub class has additional history tables. Populates custom history tables.
*
* @param fiscalYear fiscal year populate should start from
*/
public void customPopulateHistoryTables(Integer fiscalYear) {
return;
}
/**
* Possible override if sub class has additional history tables. This returns true if value populated in any such tables.
*
* @param fiscalYear given fiscal year
* @return if data exists for any such table for given year
*/
protected boolean doesCustomHistoryExist(Integer fiscalYear) {
return false;
}
/**
* Possible override if sub class has additional history tables. Deletes data in history table. Also should print message to
* that affect to be consistent with rest of functionality.
*
* @param fiscalYear given fiscal year
*/
protected void deleteCustomHistory(Integer fiscalYear) {
return;
}
/**
* Possible override if sub class has additional history tables. Updates history data for custom table(s).
*
* @param originEntry representing the update details
*/
protected void updateCustomHistory(Integer postMode, OriginEntryInformation originEntry) {
return;
}
/**
* Possible override if sub class has additional history tables.
*
* @return compare failures. As a HashMap of key: businessObjectName, value: count
*/
protected Map<String, Integer> customCompareHistory() {
return null;
}
/**
* Possible override if sub class has additional history tables. Prints the row count history for STATISTICS section.
*
* @param fiscalYear starting from which fiscal year the comparision should take place
*/
protected void customPrintRowCountHistory(Integer fiscalYear) {
return;
}
/**
* Sets the ParameterService
*
* @param parameterService The ParameterService to set.
*/
public void setParameterService(ParameterService parameterService) {
this.parameterService = parameterService;
}
/**
* Sets the ConfigurationService
*
* @param kualiConfigurationService The ConfigurationService to set.
*/
public void setConfigurationService(ConfigurationService kualiConfigurationService) {
this.kualiConfigurationService = kualiConfigurationService;
}
/**
* Sets the BusinessObjectService
*
* @param businessObjectService The BusinessObjectService to set.
*/
public void setBusinessObjectService(BusinessObjectService businessObjectService) {
this.businessObjectService = businessObjectService;
}
/**
* Sets the DateTimeService
*
* @param dateTimeService The DateTimeService to set.
*/
public void setDateTimeService(DateTimeService dateTimeService) {
this.dateTimeService = dateTimeService;
}
/**
* Sets the UniversityDateService
*
* @param universityDateService The UniversityDateService to set.
*/
public void setUniversityDateService(UniversityDateService universityDateService) {
this.universityDateService = universityDateService;
}
/**
* Sets the LedgerBalancingDao
*
* @param ledgerBalancingDao The LedgerBalancingDao to set.
*/
public void setLedgerBalancingDao(LedgerBalancingDao ledgerBalancingDao) {
this.ledgerBalancingDao = ledgerBalancingDao;
}
/**
* Sets the LedgerEntryBalancingDao
*
* @param ledgerEntryBalancingDao The LedgerEntryBalancingDao to set.
*/
public void setLedgerEntryBalancingDao(LedgerEntryBalancingDao ledgerEntryBalancingDao) {
this.ledgerEntryBalancingDao = ledgerEntryBalancingDao;
}
/**
* Sets the LedgerBalanceBalancingDao
*
* @param ledgerBalanceBalancingDao The LedgerBalanceBalancingDao to set.
*/
public void setLedgerBalanceBalancingDao(LedgerBalanceBalancingDao ledgerBalanceBalancingDao) {
this.ledgerBalanceBalancingDao = ledgerBalanceBalancingDao;
}
/**
* Sets the ledgerBalanceHistoryBalancingDao
*
* @param ledgerBalanceHistoryBalancingDao The LedgerBalanceHistoryBalancingDao to set.
*/
public void setLedgerBalanceHistoryBalancingDao(LedgerBalanceHistoryBalancingDao ledgerBalanceHistoryBalancingDao) {
this.ledgerBalanceHistoryBalancingDao = ledgerBalanceHistoryBalancingDao;
}
/**
* Sets the LedgerEntryHistoryBalancingDao
*
* @param ledgerEntryHistoryBalancingDao The LedgerEntryHistoryBalancingDao to set.
*/
public void setLedgerEntryHistoryBalancingDao(LedgerEntryHistoryBalancingDao ledgerEntryHistoryBalancingDao) {
this.ledgerEntryHistoryBalancingDao = ledgerEntryHistoryBalancingDao;
}
/**
* Sets the reportWriterService
*
* @param reportWriterService The reportWriterService to set.
*/
public void setReportWriterService(ReportWriterService reportWriterService) {
this.reportWriterService = reportWriterService;
}
/**
* Sets the batchFileDirectoryName
*
* @param batchFileDirectoryName The batchFileDirectoryName to set.
*/
public void setBatchFileDirectoryName(String batchFileDirectoryName) {
this.batchFileDirectoryName = batchFileDirectoryName;
}
/**
* Sets the ledgerEntryBalanceCachingDao attribute value.
*
* @param ledgerEntryBalanceCachingDao The ledgerEntryBalanceCachingDao to set.
*/
public void setLedgerEntryBalanceCachingDao(LedgerEntryBalanceCachingDao ledgerEntryBalanceCachingDao) {
this.ledgerEntryBalanceCachingDao = ledgerEntryBalanceCachingDao;
}
/**
* Sets the persistenceStructureService.
*
* @param persistenceStructureService
*/
public void setPersistenceStructureService(PersistenceStructureService persistenceStructureService) {
this.persistenceStructureService = persistenceStructureService;
}
}