/*
* 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.sys.service.impl;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.kuali.kfs.sys.KFSConstants;
import org.kuali.kfs.sys.Message;
import org.kuali.kfs.sys.batch.service.WrappingBatchService;
import org.kuali.kfs.sys.context.SpringContext;
import org.kuali.kfs.sys.report.BusinessObjectReportHelper;
import org.kuali.kfs.sys.service.ReportWriterService;
import org.kuali.rice.core.api.datetime.DateTimeService;
import org.kuali.rice.krad.bo.BusinessObject;
import org.kuali.rice.krad.util.ObjectUtils;
/**
* Text output implementation of <code>ReportWriterService</code> interface. If you are a developer attempting to add a new business
* object for error report writing, take a look at the Spring definitions for BusinessObjectReportHelper.<br>
* This class CANNOT be used by 2 processes simultaneously. It is for very specific batch processes that should not run at the same
* time, and initialize and destroy must be called and the beginning and end of each process that uses it.
*
* @see org.kuali.kfs.sys.report.BusinessObjectReportHelper
*/
public class ReportWriterTextServiceImpl implements ReportWriterService, WrappingBatchService {
private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(ReportWriterTextServiceImpl.class);
// Changing the initial line number would only affect that a page break occurs early. It does not actually print in the
// middle of the page. Hence changing this has little use.
protected static final int INITIAL_LINE_NUMBER = 0;
protected String filePath;
protected String fileNamePrefix;
protected String fileNameSuffix;
protected String title;
protected int pageWidth;
protected int pageLength;
protected int initialPageNumber;
protected String errorSubTitle;
protected String statisticsLabel;
protected String statisticsLeftPadding;
private String parametersLabel;
private String parametersLeftPadding;
protected String pageLabel;
protected String newLineCharacter;
protected DateTimeService dateTimeService;
protected boolean aggregationModeOn;
/**
* A map of BO classes to {@link BusinessObjectReportHelper} bean names, to configure which BO's will be rendered by which
* BusinessObjectReportHelper. This property should be configured via the spring bean definition
*/
protected Map<Class<? extends BusinessObject>, String> classToBusinessObjectReportHelperBeanNames;
// Local caching field to speed up the selection of formatting BusinessObjectReportHelper to use per configuration in Spring
protected Map<Class<? extends BusinessObject>, BusinessObjectReportHelper> businessObjectReportHelpers;
protected PrintStream printStream;
protected int page;
protected int line = INITIAL_LINE_NUMBER;
protected String errorFormat;
// Ensures that the statistics header isn't written multiple times. Does not check that a user doesn't write other stuff into
// the statistics
// section. A developer is responsible for ensuring that themselves
protected boolean modeStatistics = false;
// Ensures that the parameters header isn't written multiple times. Does not check that a user doesn't write other stuff into
// the parameters
// section. A developer is responsible for ensuring that themselves
protected boolean modeParameters = false;
// So that writeError knows when to writeErrorHeader
protected boolean newPage = true;
// For printing new headers when the BO is changed
protected Class<? extends BusinessObject> businessObjectClass;
public ReportWriterTextServiceImpl() {
// TODO Auto-generated constructor stub
}
/**
* @see org.kuali.kfs.sys.batch.service.WrappingBatchService#initialize()
*/
public void initialize() {
try {
printStream = new PrintStream(generateFullFilePath());
}
catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
page = initialPageNumber;
initializeBusinessObjectReportHelpers();
// Initial header
this.writeHeader(title);
}
protected void initializeBusinessObjectReportHelpers() {
businessObjectReportHelpers = new HashMap<Class<? extends BusinessObject>, BusinessObjectReportHelper>();
if (classToBusinessObjectReportHelperBeanNames != null) {
for (Class<? extends BusinessObject> clazz : classToBusinessObjectReportHelperBeanNames.keySet()) {
String businessObjectReportHelperBeanName = classToBusinessObjectReportHelperBeanNames.get(clazz);
BusinessObjectReportHelper reportHelper = (BusinessObjectReportHelper) SpringContext.getService(businessObjectReportHelperBeanName);
if (ObjectUtils.isNull(reportHelper)) {
LOG.error("Cannot find BusinessObjectReportHelper implementation for class: " + clazz.getName() + " bean name: " + businessObjectReportHelperBeanName);
throw new RuntimeException("Cannot find BusinessObjectReportHelper implementation for class: " + clazz.getName() + " bean name: " + businessObjectReportHelperBeanName);
}
businessObjectReportHelpers.put(clazz, reportHelper);
}
}
}
protected String generateFullFilePath() {
if (aggregationModeOn) {
return filePath + File.separator + this.fileNamePrefix + fileNameSuffix;
}
else {
return filePath + File.separator + this.fileNamePrefix + dateTimeService.toDateTimeStringForFilename(dateTimeService.getCurrentDate()) + fileNameSuffix;
}
}
/**
* @see org.kuali.kfs.sys.batch.service.WrappingBatchService#destroy()
*/
public void destroy() {
if(printStream != null) {
printStream.close();
printStream = null;
}
// reset variables that track state
page = initialPageNumber;
line = INITIAL_LINE_NUMBER;
modeStatistics = false;
modeParameters = false;
newPage = true;
businessObjectClass = null;
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeSubTitle(java.lang.String)
*/
public void writeSubTitle(String message) {
if (message.length() > pageWidth) {
LOG.warn("sub title to be written exceeds pageWidth. Printing anyway.");
this.writeFormattedMessageLine(message);
}
else {
int padding = (pageWidth - message.length()) / 2;
this.writeFormattedMessageLine("%" + (padding + message.length()) + "s", message);
}
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeError(java.lang.Class, org.kuali.kfs.sys.Message)
*/
public void writeError(BusinessObject businessObject, Message message) {
this.writeError(businessObject, message, true);
}
/**
* @param printBusinessObjectValues indicates whether the bo values should be printed before the message
* @see org.kuali.kfs.sys.service.ReportWriterService#writeError(java.lang.Class, org.kuali.kfs.sys.Message)
*/
public void writeError(BusinessObject businessObject, Message message, boolean printBusinessObjectValues) {
// Check if we need to write a new table header. We do this if it hasn't been written before or if the businessObject
// changed
if (newPage || businessObjectClass == null || !businessObjectClass.getName().equals(businessObject.getClass().getName())) {
if (businessObjectClass == null) {
// If we didn't write the header before, write it with a subTitle
this.writeSubTitle(errorSubTitle);
}
else if (!businessObjectClass.getName().equals(businessObject.getClass().getName())) {
// If it changed push a newline in for neater formatting
this.writeNewLines(1);
}
this.writeErrorHeader(businessObject);
newPage = false;
businessObjectClass = businessObject.getClass();
}
// Get business object formatter that will be used
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
// Print the values of the businessObject per formatting determined by writeErrorHeader
List<Object> formatterArgs = new ArrayList<Object>();
if (printBusinessObjectValues) {
formatterArgs.addAll(businessObjectReportHelper.getValues(businessObject));
}
else {
formatterArgs.addAll(businessObjectReportHelper.getBlankValues(businessObject));
}
// write rest of message on new line(s) if it was cut off
int maxMessageLength = Integer.parseInt(StringUtils.substringBefore(StringUtils.substringAfterLast(errorFormat, "%-"), "s"));
String messageToPrint = message.getMessage();
boolean firstMessageLine = true;
while (messageToPrint.length() > 0 && StringUtils.isNotBlank(messageToPrint)) {
if (!firstMessageLine) {
formatterArgs = new ArrayList<Object>();
formatterArgs.addAll(businessObjectReportHelper.getBlankValues(businessObject));
}
else {
firstMessageLine = false;
}
messageToPrint = StringUtils.trim(messageToPrint);
String messageLine = messageToPrint;
if (messageLine.length() > maxMessageLength) {
messageLine = StringUtils.substring(messageLine, 0, maxMessageLength);
if (StringUtils.contains(messageLine, " ")) {
messageLine = StringUtils.substringBeforeLast(messageLine, " ");
}
}
formatterArgs.add(new Message(messageLine, message.getType()));
this.writeFormattedMessageLine(errorFormat, formatterArgs.toArray());
messageToPrint = StringUtils.removeStart(messageToPrint, messageLine);
}
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeError(java.lang.Class, java.util.List)
*/
public void writeError(BusinessObject businessObject, List<Message> messages) {
int i = 0;
for (Iterator<Message> messagesIter = messages.iterator(); messagesIter.hasNext();) {
Message message = messagesIter.next();
if (i == 0) {
// First one has its values written
this.writeError(businessObject, message, true);
}
else {
// Any consecutive one only has message written
this.writeError(businessObject, message, false);
}
i++;
}
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeNewLines(int)
*/
public void writeNewLines(int lines) {
for (int i = 0; i < lines; i++) {
this.writeFormattedMessageLine("");
}
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeStatisticLine(java.lang.String, java.lang.Object[])
*/
public void writeStatisticLine(String message, Object... args) {
// Statistics header is only written if it hasn't been written before
if (!modeStatistics) {
this.modeStatistics = true;
// If nothing has been written to the report we don't want to page break
if (!(page == initialPageNumber && line == INITIAL_LINE_NUMBER + 2)) {
this.pageBreak();
}
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*******************" + statisticsLabel + "*******************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
}
this.writeFormattedMessageLine(statisticsLeftPadding + message, args);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeParameterLine(java.lang.String, java.lang.Object[])
*/
public void writeParameterLine(String message, Object... args) {
// Statistics header is only written if it hasn't been written before
if (!modeParameters) {
this.modeParameters = true;
// If nothing has been written to the report we don't want to page break
if (!(page == initialPageNumber && line == INITIAL_LINE_NUMBER + 2)) {
this.pageBreak();
}
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*******************" + getParametersLabel() + "*******************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
this.writeFormattedMessageLine("*********************************************************************************************************************************");
}
this.writeFormattedMessageLine(getParametersLeftPadding() + message, args);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeFormattedMessageLine(java.lang.String, java.lang.Object[])
*/
public void writeFormattedMessageLine(String format, Object... args) {
if (format.indexOf("% s") > -1) {
LOG.warn("Cannot properly format: "+format);
}
else {
Object[] escapedArgs = escapeArguments(args);
if (LOG.isDebugEnabled()) {
LOG.debug("writeFormattedMessageLine, format: "+format);
}
String message = null;
if (escapedArgs.length > 0) {
message = String.format(format + newLineCharacter, escapedArgs);
} else {
message = format+newLineCharacter;
}
// Log we are writing out of bounds. Would be nice to show message here but not so sure if it's wise to dump that data into
// logs
if (message.length() > pageWidth) {
if (LOG.isDebugEnabled()) {
LOG.debug("message is out of bounds writing anyway");
}
}
printStream.print(message);
printStream.flush();
line++;
if (line >= pageLength) {
this.pageBreak();
}
}
}
/**
* Determines if all formatting on the given String is escaped - ie, that it has no formatting
* @param format the format to test
* @return true if the String is without formatting, false otherwise
*/
protected boolean allFormattingEscaped(String format) {
int currPoint = 0;
int currIndex = format.indexOf('%', currPoint);
while (currIndex > -1) {
char nextChar = format.charAt(currIndex+1);
if (nextChar != '%') {
return false;
}
currPoint = currIndex + 2;
}
return true;
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#pageBreak()
*/
public void pageBreak() {
// Intentionally not using writeFormattedMessageLine here since it would loop trying to page break ;)
// 12 represents the ASCII Form Feed character
printStream.printf("%c" + newLineCharacter, 12);
page++;
line = INITIAL_LINE_NUMBER;
newPage = true;
this.writeHeader(title);
}
/**
* Helper method to write a header for placement at top of new page
*
* @param title that should be printed on this header
*/
protected void writeHeader(String title) {
String headerText = String.format("%1$tY-%1$tm-%1$td %1$tH:%1$tM", dateTimeService.getCurrentDate());
int reportTitlePadding = pageWidth / 2 - headerText.length() - title.length() / 2;
headerText = String.format("%s%" + (reportTitlePadding + title.length()) + "s%" + reportTitlePadding + "s", headerText, title, "");
if (aggregationModeOn) {
this.writeFormattedMessageLine("%s%s%s", headerText, pageLabel, KFSConstants.REPORT_WRITER_SERVICE_PAGE_NUMBER_PLACEHOLDER);
}
else {
this.writeFormattedMessageLine("%s%s%,9d", headerText, pageLabel, page);
}
this.writeNewLines(1);
}
/**
* Helper method to write the error header
*
* @param businessObject to print header for
*/
protected void writeErrorHeader(BusinessObject businessObject) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
List<String> errorHeader = businessObjectReportHelper.getTableHeader(pageWidth);
// If we are at end of page and don't have space for table header, go ahead and page break
if (errorHeader.size() + line >= pageLength) {
this.pageBreak();
}
// Print the header one by one. Note the last element is the formatter. So capture that seperately
for (Iterator<String> headers = errorHeader.iterator(); headers.hasNext();) {
String header = headers.next();
if (headers.hasNext()) {
this.writeFormattedMessageLine("%s", header);
}
else {
errorFormat = header;
}
}
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeTableHeader(org.kuali.rice.krad.bo.BusinessObject)
*/
public void writeTableHeader(BusinessObject businessObject) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String tableHeaderFormat = tableDefinition.get(KFSConstants.ReportConstants.TABLE_HEADER_LINE_KEY);
String[] headerLines = this.getMultipleFormattedMessageLines(tableHeaderFormat, new Object());
this.writeMultipleFormattedMessageLines(headerLines);
}
/**
* Writes out the table header, based on a business object class
* @param businessObjectClass the class to write the header out for
*/
public void writeTableHeader(Class<? extends BusinessObject> businessObjectClass) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObjectClass);
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String tableHeaderFormat = tableDefinition.get(KFSConstants.ReportConstants.TABLE_HEADER_LINE_KEY);
String[] headerLines = this.getMultipleFormattedMessageLines(tableHeaderFormat, new Object());
this.writeMultipleFormattedMessageLines(headerLines);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeTableRow(org.kuali.rice.krad.bo.BusinessObject)
*/
public void writeTableRowSeparationLine(BusinessObject businessObject) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String separationLine = tableDefinition.get(KFSConstants.ReportConstants.SEPARATOR_LINE_KEY);
this.writeFormattedMessageLine(separationLine);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeTableRow(org.kuali.rice.krad.bo.BusinessObject)
*/
public void writeTableRow(BusinessObject businessObject) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String tableCellFormat = tableDefinition.get(KFSConstants.ReportConstants.TABLE_CELL_FORMAT_KEY);
List<String> tableCellValues = businessObjectReportHelper.getTableCellValuesPaddingWithEmptyCell(businessObject, false);
String[] rowMessageLines = this.getMultipleFormattedMessageLines(tableCellFormat, tableCellValues.toArray());
this.writeMultipleFormattedMessageLines(rowMessageLines);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeTableRowWithColspan(org.kuali.rice.krad.bo.BusinessObject)
*/
public void writeTableRowWithColspan(BusinessObject businessObject) {
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObject);
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String tableCellFormat = businessObjectReportHelper.getTableCellFormat(true, true, StringUtils.EMPTY);
List<String> tableCellValues = businessObjectReportHelper.getTableCellValuesPaddingWithEmptyCell(businessObject, true);
String[] rowMessageLines = this.getMultipleFormattedMessageLines(tableCellFormat, tableCellValues.toArray());
this.writeMultipleFormattedMessageLines(rowMessageLines);
}
/**
* @see org.kuali.kfs.sys.service.ReportWriterService#writeTable(java.util.List, boolean, boolean)
*/
public void writeTable(List<? extends BusinessObject> businessObjects, boolean isHeaderRepeatedInNewPage, boolean isRowBreakAcrossPageAllowed) {
if (ObjectUtils.isNull(businessObjects) || businessObjects.isEmpty()) {
return;
}
BusinessObject firstBusinessObject = businessObjects.get(0);
this.writeTableHeader(firstBusinessObject);
BusinessObjectReportHelper businessObjectReportHelper = getBusinessObjectReportHelper(businessObjects.get(0));
Map<String, String> tableDefinition = businessObjectReportHelper.getTableDefinition();
String tableHeaderFormat = tableDefinition.get(KFSConstants.ReportConstants.TABLE_HEADER_LINE_KEY);
String[] headerLines = this.getMultipleFormattedMessageLines(tableHeaderFormat, new Object());
String tableCellFormat = tableDefinition.get(KFSConstants.ReportConstants.TABLE_CELL_FORMAT_KEY);
for (BusinessObject businessObject : businessObjects) {
List<String> tableCellValues = businessObjectReportHelper.getTableCellValuesPaddingWithEmptyCell(businessObject, false);
String[] messageLines = this.getMultipleFormattedMessageLines(tableCellFormat, tableCellValues.toArray());
boolean hasEnoughLinesInPage = messageLines.length <= (this.pageLength - this.line);
if (!hasEnoughLinesInPage && !isRowBreakAcrossPageAllowed) {
this.pageBreak();
if (isHeaderRepeatedInNewPage) {
this.writeTableHeader(firstBusinessObject);
}
}
this.writeMultipleFormattedMessageLines(messageLines, headerLines, isRowBreakAcrossPageAllowed);
}
}
/**
* get the business report helper for the given business object
*
* @param businessObject the given business object
* @return the business report helper for the given business object
*/
public BusinessObjectReportHelper getBusinessObjectReportHelper(BusinessObject businessObject) {
if (LOG.isDebugEnabled()) {
if (businessObject == null) {
LOG.debug("reporting "+filePath+" but can't because null business object sent in");
} else if (businessObjectReportHelpers == null) {
LOG.debug("Logging "+businessObject+" in report "+filePath+" but businessObjectReportHelpers are null");
}
}
BusinessObjectReportHelper businessObjectReportHelper = this.businessObjectReportHelpers.get(businessObject.getClass());
if (ObjectUtils.isNull(businessObjectReportHelper)) {
throw new RuntimeException(businessObject.getClass().toString() + " is not handled");
}
return businessObjectReportHelper;
}
/**
* get the business report helper for the given business object
*
* @param businessObject the given business object
* @return the business report helper for the given business object
*/
public BusinessObjectReportHelper getBusinessObjectReportHelper(Class<? extends BusinessObject> businessObjectClass) {
BusinessObjectReportHelper businessObjectReportHelper = this.businessObjectReportHelpers.get(businessObjectClass);
if (ObjectUtils.isNull(businessObjectReportHelper)) {
throw new RuntimeException(businessObjectClass.getName() + " is not handled");
}
return businessObjectReportHelper;
}
/**
* write the given information as multiple lines if it contains more than one line breaks
*
* @param format the given text format definition
* @param messageLines the given information being written out
* @param headerLinesInNewPage the given header lines being written in the begin of a new page
*/
protected void writeMultipleFormattedMessageLines(String[] messageLines, String[] headerLinesInNewPage, boolean isRowBreakAcrossPageAllowed) {
int currentPageNumber = this.page;
for (String line : messageLines) {
boolean hasEnoughLinesInPage = messageLines.length <= (this.pageLength - this.line);
if (!hasEnoughLinesInPage && !isRowBreakAcrossPageAllowed) {
this.pageBreak();
}
if (currentPageNumber < this.page && ObjectUtils.isNotNull(headerLinesInNewPage)) {
currentPageNumber = this.page;
for (String headerLine : headerLinesInNewPage) {
this.writeFormattedMessageLine(headerLine);
}
}
this.writeFormattedMessageLine(line);
}
}
/**
* write the given information as multiple lines if it contains more than one line breaks
*
* @param format the given text format definition
* @param args the given information being written out
*/
public void writeMultipleFormattedMessageLines(String[] messageLines) {
this.writeMultipleFormattedMessageLines(messageLines, null, false);
}
public void writeMultipleFormattedMessageLines(String format, Object... args) {
Object[] escapedArgs = escapeArguments(args);
String[] messageLines = getMultipleFormattedMessageLines(format, escapedArgs);
writeMultipleFormattedMessageLines(messageLines);
}
/**
* This method...
*
* @param format
* @param args
* @return
*/
public String[] getMultipleFormattedMessageLines(String format, Object... args) {
Object[] escapedArgs = escapeArguments(args);
String message = String.format(format, escapedArgs);
return StringUtils.split(message, newLineCharacter);
}
/**
* Iterates through array and escapes special formatting characters
*
* @param args Object array to process
* @return Object array with String members escaped
*/
protected Object[] escapeArguments(Object... args) {
Object[] escapedArgs = new Object[args.length];
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
if (arg == null) {
args[i] = "";
} else if (arg != null && arg instanceof String) {
String escapedArg = escapeFormatCharacters((String)arg);
escapedArgs[i] = escapedArg;
}
else {
escapedArgs[i] = arg;
}
}
return escapedArgs;
}
/**
* Escapes characters in a string that have special meaning for formatting
*
* @param replacementString string to escape
* @return string with format characters escaped
* @see KFSConstants.ReportConstants.FORMAT_ESCAPE_CHARACTERS
*/
protected String escapeFormatCharacters(String replacementString) {
String escapedString = replacementString;
for (int i = 0; i < KFSConstants.ReportConstants.FORMAT_ESCAPE_CHARACTERS.length; i++) {
String characterToEscape = KFSConstants.ReportConstants.FORMAT_ESCAPE_CHARACTERS[i];
escapedString = StringUtils.replace(escapedString, characterToEscape, characterToEscape + characterToEscape);
}
return escapedString;
}
/**
* Sets the filePath
*
* @param filePath The filePath to set.
*/
public void setFilePath(String filePath) {
this.filePath = filePath;
}
/**
* Sets the fileNamePrefix
*
* @param fileNamePrefix The fileNamePrefix to set.
*/
public void setFileNamePrefix(String fileNamePrefix) {
this.fileNamePrefix = fileNamePrefix;
}
/**
* Sets the fileNameSuffix
*
* @param fileNameSuffix The fileNameSuffix to set.
*/
public void setFileNameSuffix(String fileNameSuffix) {
this.fileNameSuffix = fileNameSuffix;
}
/**
* Sets the title
*
* @param title The title to set.
*/
public void setTitle(String title) {
this.title = title;
}
/**
* Sets the pageWidth
*
* @param pageWidth The pageWidth to set.
*/
public void setPageWidth(int pageWidth) {
this.pageWidth = pageWidth;
}
/**
* Sets the pageLength
*
* @param pageLength The pageLength to set.
*/
public void setPageLength(int pageLength) {
this.pageLength = pageLength;
}
/**
* Sets the initialPageNumber
*
* @param initialPageNumber The initialPageNumber to set.
*/
public void setInitialPageNumber(int initialPageNumber) {
this.initialPageNumber = initialPageNumber;
}
/**
* Sets the errorSubTitle
*
* @param errorSubTitle The errorSubTitle to set.
*/
public void setErrorSubTitle(String errorSubTitle) {
this.errorSubTitle = errorSubTitle;
}
/**
* Sets the statisticsLabel
*
* @param statisticsLabel The statisticsLabel to set.
*/
public void setStatisticsLabel(String statisticsLabel) {
this.statisticsLabel = statisticsLabel;
}
/**
* Sets the statisticsLeftPadding
*
* @param statisticsLeftPadding The statisticsLeftPadding to set.
*/
public void setStatisticsLeftPadding(String statisticsLeftPadding) {
this.statisticsLeftPadding = statisticsLeftPadding;
}
/**
* Sets the pageLabel
*
* @param pageLabel The pageLabel to set.
*/
public void setPageLabel(String pageLabel) {
this.pageLabel = pageLabel;
}
/**
* Sets the newLineCharacter
*
* @param newLineCharacter The newLineCharacter to set.
*/
public void setNewLineCharacter(String newLineCharacter) {
this.newLineCharacter = newLineCharacter;
}
/**
* Sets the DateTimeService
*
* @param dateTimeService The DateTimeService to set.
*/
public void setDateTimeService(DateTimeService dateTimeService) {
this.dateTimeService = dateTimeService;
}
/**
* Sets a map of BO classes to {@link BusinessObjectReportHelper} bean names, to configure which BO's will be rendered by which
* BusinessObjectReportHelper. This property should be configured via the spring bean definition
*
* @param classToBusinessObjectReportHelperBeanNames The classToBusinessObjectReportHelperBeanNames to set.
*/
public void setClassToBusinessObjectReportHelperBeanNames(Map<Class<? extends BusinessObject>, String> classToBusinessObjectReportHelperBeanNames) {
this.classToBusinessObjectReportHelperBeanNames = classToBusinessObjectReportHelperBeanNames;
}
/**
* Gets the parametersLabel attribute.
* @return Returns the parametersLabel.
*/
public String getParametersLabel() {
return parametersLabel;
}
/**
* Sets the parametersLabel attribute value.
* @param parametersLabel The parametersLabel to set.
*/
public void setParametersLabel(String parametersLabel) {
this.parametersLabel = parametersLabel;
}
/**
* Gets the parametersLeftPadding attribute.
* @return Returns the parametersLeftPadding.
*/
public String getParametersLeftPadding() {
return parametersLeftPadding;
}
/**
* Sets the parametersLeftPadding attribute value.
* @param parametersLeftPadding The parametersLeftPadding to set.
*/
public void setParametersLeftPadding(String parametersLeftPadding) {
this.parametersLeftPadding = parametersLeftPadding;
}
/**
* Gets the aggregationModeOn attribute.
* @return Returns the aggregationModeOn.
*/
public boolean isAggregationModeOn() {
return aggregationModeOn;
}
/**
* Sets the aggregationModeOn attribute value.
* @param aggregationModeOn The aggregationModeOn to set.
*/
public void setAggregationModeOn(boolean aggregationModeOn) {
this.aggregationModeOn = aggregationModeOn;
}
}