Java tutorial
/* * Copyright 2009 The Kuali Foundation * * Licensed under the Educational Community License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.opensource.org/licenses/ecl2.php * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.kuali.ole.sys.report; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.commons.beanutils.PropertyUtils; import org.apache.commons.lang.StringUtils; import org.kuali.ole.sys.OLEConstants; import org.kuali.rice.core.web.format.BigDecimalFormatter; import org.kuali.rice.core.web.format.CurrencyFormatter; import org.kuali.rice.core.web.format.Formatter; import org.kuali.rice.core.web.format.IntegerFormatter; import org.kuali.rice.core.web.format.KualiIntegerCurrencyFormatter; import org.kuali.rice.core.web.format.LongFormatter; import org.kuali.rice.core.web.format.PercentageFormatter; import org.kuali.rice.kns.service.DataDictionaryService; import org.kuali.rice.krad.bo.BusinessObject; import org.kuali.rice.krad.util.ObjectUtils; /** * Helper class for business objects to assist formatting them for error reporting. Utilizes spring injection for modularization and * configurability * * @see org.kuali.ole.sys.service.impl.ReportWriterTextServiceImpl */ public class BusinessObjectReportHelper { private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger .getLogger(BusinessObjectReportHelper.class); protected int minimumMessageLength; protected String messageLabel; protected Class<? extends BusinessObject> dataDictionaryBusinessObjectClass; protected Map<String, String> orderedPropertyNameToHeaderLabelMap; protected DataDictionaryService dataDictionaryService; private int columnCount = 0; private Map<String, Integer> columnSpanDefinition; public final static String LEFT_ALIGNMENT = "LEFT"; public final static String RIGHT_ALIGNMENT = "RIGHT"; public final static String LINE_BREAK = "\n"; /** * Returns the values in a list of the passed in business object in order of the spring definition. * * @param businessObject for which to return the values * @return the values */ public List<Object> getValues(BusinessObject businessObject) { List<Object> keys = new ArrayList<Object>(); for (Iterator<String> propertyNames = orderedPropertyNameToHeaderLabelMap.keySet().iterator(); propertyNames .hasNext();) { String propertyName = propertyNames.next(); keys.add(retrievePropertyValue(businessObject, propertyName)); } return keys; } /** * Returns a value for a given property, can be overridden to allow for pseudo-properties * * @param businessObject * @param propertyName * @return */ protected Object retrievePropertyValue(BusinessObject businessObject, String propertyName) { try { return PropertyUtils.getProperty(businessObject, propertyName); } catch (Exception e) { throw new RuntimeException("Failed getting propertyName=" + propertyName + " from businessObjecName=" + businessObject.getClass().getName(), e); } } /** * Returns the maximum length of a value for a given propery, can be overridden to allow for pseudo-properties * * @param businessObjectClass * @param propertyName * @return */ protected int retrievePropertyValueMaximumLength(Class<? extends BusinessObject> businessObjectClass, String propertyName) { return dataDictionaryService.getAttributeMaxLength(businessObjectClass, propertyName); } /** * Returns the maximum length of a value for a given propery, can be overridden to allow for pseudo-properties * * @param businessObjectClass * @param propertyName * @return */ protected Class<? extends Formatter> retrievePropertyFormatterClass( Class<? extends BusinessObject> businessObjectClass, String propertyName) { return dataDictionaryService.getAttributeFormatter(businessObjectClass, propertyName); } /** * Same as getValues except that it actually doesn't retrieve the values from the BO but instead returns a blank linke. This is * useful if indentation for message printing is necessary. * * @param businessObject for which to return the values * @return spaces in the length of values */ public List<Object> getBlankValues(BusinessObject businessObject) { List<Object> keys = new ArrayList<Object>(); for (Iterator<String> propertyNames = orderedPropertyNameToHeaderLabelMap.keySet().iterator(); propertyNames .hasNext();) { String propertyName = propertyNames.next(); keys.add(""); } return keys; } /** * Returns multiple lines of what represent a table header. The last line in this list is the format of the table cells. * * @param maximumPageWidth maximum before line is out of bounds. Used to fill message to the end of this range. Note that if * there isn't at least maximumPageWidth characters available it will go minimumMessageLength out of bounds. It is up to * the calling class to handle that * @return table header. Last element is the format of the table cells. */ public List<String> getTableHeader(int maximumPageWidth) { String separatorLine = StringUtils.EMPTY; String messageFormat = StringUtils.EMPTY; // Construct the header based on orderedPropertyNameToHeaderLabelMap. It will pick the longest of label or DD size for (Iterator<Map.Entry<String, String>> entries = orderedPropertyNameToHeaderLabelMap.entrySet() .iterator(); entries.hasNext();) { Map.Entry<String, String> entry = entries.next(); int longest; try { longest = retrievePropertyValueMaximumLength(dataDictionaryBusinessObjectClass, entry.getKey()); } catch (Exception e) { throw new RuntimeException("Failed getting propertyName=" + entry.getKey() + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e); } if (entry.getValue().length() > longest) { longest = entry.getValue().length(); } separatorLine = separatorLine + StringUtils.rightPad("", longest, OLEConstants.DASH) + " "; messageFormat = messageFormat + "%-" + longest + "s "; } // Now fill to the end of pageWidth for the message column. If there is not enough space go out of bounds int availableWidth = maximumPageWidth - (separatorLine.length() + 1); if (availableWidth < minimumMessageLength) { availableWidth = minimumMessageLength; } separatorLine = separatorLine + StringUtils.rightPad("", availableWidth, OLEConstants.DASH); messageFormat = messageFormat + "%-" + availableWidth + "s"; // Fill in the header labels. We use the errorFormat to do this to get justification right List<Object> formatterArgs = new ArrayList<Object>(); formatterArgs.addAll(orderedPropertyNameToHeaderLabelMap.values()); formatterArgs.add(messageLabel); String tableHeaderLine = String.format(messageFormat, formatterArgs.toArray()); // Construct return list List<String> tableHeader = new ArrayList<String>(); tableHeader.add(tableHeaderLine); tableHeader.add(separatorLine); tableHeader.add(messageFormat); return tableHeader; } /** * get the primary information that can define a table structure * * @return the primary information that can define a table structure */ public Map<String, String> getTableDefinition() { List<Integer> cellWidthList = this.getTableCellWidth(); String separatorLine = this.getSepartorLine(cellWidthList); String tableCellFormat = this.getTableCellFormat(false, true, null); String tableHeaderLineFormat = this.getTableCellFormat(false, false, separatorLine); // fill in the header labels int numberOfCell = cellWidthList.size(); List<String> tableHeaderLabelValues = new ArrayList<String>(orderedPropertyNameToHeaderLabelMap.values()); this.paddingTableCellValues(numberOfCell, tableHeaderLabelValues); String tableHeaderLine = String.format(tableHeaderLineFormat, tableHeaderLabelValues.toArray()); Map<String, String> tableDefinition = new HashMap<String, String>(); tableDefinition.put(OLEConstants.ReportConstants.TABLE_HEADER_LINE_KEY, tableHeaderLine); tableDefinition.put(OLEConstants.ReportConstants.SEPARATOR_LINE_KEY, separatorLine); tableDefinition.put(OLEConstants.ReportConstants.TABLE_CELL_FORMAT_KEY, tableCellFormat); return tableDefinition; } /** * Returns the values in a list of the passed in business object in order of the spring definition. The value for the * "EMPTY_CELL" entry is an empty string. * * @param businessObject for which to return the values * @param allowColspan indicate whether colspan definition can be applied * @return the values being put into the table cells */ public List<String> getTableCellValues(BusinessObject businessObject, boolean allowColspan) { List<String> tableCellValues = new ArrayList<String>(); for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) { String attributeName = entry.getKey(); if (attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) { tableCellValues.add(StringUtils.EMPTY); } else { try { Object propertyValue = retrievePropertyValue(businessObject, attributeName); if (ObjectUtils.isNotNull(propertyValue)) { Formatter formatter = Formatter.getFormatter(propertyValue.getClass()); if (ObjectUtils.isNotNull(formatter) && ObjectUtils.isNotNull(propertyValue)) { propertyValue = formatter.format(propertyValue); } else { propertyValue = StringUtils.EMPTY; } } else { propertyValue = StringUtils.EMPTY; } tableCellValues.add(propertyValue.toString()); } catch (Exception e) { throw new RuntimeException("Failed getting propertyName=" + entry.getKey() + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e); } } } if (allowColspan) { this.applyColspanOnCellValues(tableCellValues); } return tableCellValues; } /** * get the format string for all cells in a table row. Colspan definition will be applied if allowColspan is true * * @param allowColspan indicate whether colspan definition can be applied * @param allowRightAlignment indicate whether the right alignment can be applied * @param separatorLine the separation line for better look * * @return the format string for all cells in a table row */ public String getTableCellFormat(boolean allowColspan, boolean allowRightAlignment, String separatorLine) { List<Integer> cellWidthList = this.getTableCellWidth(); List<String> cellAlignmentList = this.getTableCellAlignment(); if (allowColspan) { this.applyColspanOnCellWidth(cellWidthList); } int numberOfCell = cellWidthList.size(); int rowCount = (int) Math.ceil(numberOfCell * 1.0 / columnCount); StringBuffer tableCellFormat = new StringBuffer(); for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) { StringBuffer singleRowFormat = new StringBuffer(); for (int columnIndex = 0; columnIndex < this.columnCount; columnIndex++) { int index = columnCount * rowIndex + columnIndex; if (index >= numberOfCell) { break; } int width = cellWidthList.get(index); String alignment = (allowRightAlignment && cellAlignmentList.get(index).equals(RIGHT_ALIGNMENT)) ? StringUtils.EMPTY : "-"; if (width > 0) { // following translates to %<alignment><width>.<precision>s where the precision for Strings forces a maxLength singleRowFormat = singleRowFormat.append("%").append(alignment).append(width) .append("." + width).append("s "); } } tableCellFormat = tableCellFormat.append(singleRowFormat).append(LINE_BREAK); if (StringUtils.isNotBlank(separatorLine)) { tableCellFormat = tableCellFormat.append(separatorLine).append(LINE_BREAK); } } return tableCellFormat.toString(); } /** * get the separator line * @param cellWidthList the given cell width list * @return the separator line */ public String getSepartorLine(List<Integer> cellWidthList) { StringBuffer separatorLine = new StringBuffer(); for (int index = 0; index < this.columnCount; index++) { Integer cellWidth = cellWidthList.get(index); separatorLine = separatorLine .append(StringUtils.rightPad(StringUtils.EMPTY, cellWidth, OLEConstants.DASH)).append(" "); } return separatorLine.toString(); } /** * apply the colspan definition on the default width of the table cells * * @param the default width of the table cells */ public void applyColspanOnCellWidth(List<Integer> cellWidthList) { if (ObjectUtils.isNull(columnSpanDefinition)) { return; } int indexOfCurrentCell = 0; for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) { String attributeName = entry.getKey(); if (columnSpanDefinition.containsKey(attributeName)) { int columnSpan = columnSpanDefinition.get(attributeName); int widthOfCurrentNonEmptyCell = cellWidthList.get(indexOfCurrentCell); for (int i = 1; i < columnSpan; i++) { widthOfCurrentNonEmptyCell += cellWidthList.get(indexOfCurrentCell + i); cellWidthList.set(indexOfCurrentCell + i, 0); } cellWidthList.set(indexOfCurrentCell, widthOfCurrentNonEmptyCell + columnSpan - 1); } indexOfCurrentCell++; } } /** * apply the colspan definition on the default values of the table cells. The values will be removed if their positions are taken by others. * * @param the default values of the table cells */ public void applyColspanOnCellValues(List<String> cellValues) { if (ObjectUtils.isNull(columnSpanDefinition)) { return; } String REMOVE_ME = "REMOVE-ME-!"; int indexOfCurrentCell = 0; for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) { String attributeName = entry.getKey(); if (columnSpanDefinition.containsKey(attributeName)) { int columnSpan = columnSpanDefinition.get(attributeName); for (int i = 1; i < columnSpan; i++) { cellValues.set(indexOfCurrentCell + i, REMOVE_ME); } } indexOfCurrentCell++; } int originalLength = cellValues.size(); for (int index = originalLength - 1; index >= 0; index--) { if (StringUtils.equals(cellValues.get(index), REMOVE_ME)) { cellValues.remove(index); } } } /** * get the values that can be fed into a predefined table. If the values are not enought to occupy the table cells, a number of empty values are provided. * * @param businessObject the given business object whose property values will be collected * @param allowColspan indicate whether colspan definition can be applied * @return */ public List<String> getTableCellValuesPaddingWithEmptyCell(BusinessObject businessObject, boolean allowColspan) { List<String> tableCellValues = this.getTableCellValues(businessObject, allowColspan); int numberOfCell = orderedPropertyNameToHeaderLabelMap.entrySet().size(); this.paddingTableCellValues(numberOfCell, tableCellValues); return tableCellValues; } /** * get the width of all table cells according to the definition * * @return the width of all table cells. The width is in the order defined as the orderedPropertyNameToHeaderLabelMap */ public List<Integer> getTableCellWidth() { List<Integer> cellWidthList = new ArrayList<Integer>(); for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) { String attributeName = entry.getKey(); String attributeValue = entry.getValue(); int cellWidth = attributeValue.length(); if (!attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) { try { cellWidth = retrievePropertyValueMaximumLength(dataDictionaryBusinessObjectClass, attributeName); } catch (Exception e) { throw new RuntimeException("Failed getting propertyName=" + attributeName + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e); } } if (attributeValue.length() > cellWidth) { cellWidth = attributeValue.length(); } cellWidthList.add(cellWidth); } int numberOfCell = cellWidthList.size(); int rowCount = (int) Math.ceil(numberOfCell * 1.0 / columnCount); for (int colIndex = 0; colIndex < columnCount; colIndex++) { int longestLength = cellWidthList.get(colIndex); for (int rowIndex = 1; rowIndex < rowCount; rowIndex++) { int currentIndex = rowIndex * columnCount + colIndex; if (currentIndex >= numberOfCell) { break; } int currentLength = cellWidthList.get(currentIndex); if (currentLength > longestLength) { cellWidthList.set(colIndex, currentLength); } } } for (int colIndex = 0; colIndex < columnCount; colIndex++) { int longestLength = cellWidthList.get(colIndex); for (int rowIndex = 1; rowIndex < rowCount; rowIndex++) { int currentIndex = rowIndex * columnCount + colIndex; if (currentIndex >= numberOfCell) { break; } cellWidthList.set(currentIndex, longestLength); } } return cellWidthList; } /** * get the alignment definitions of all table cells in one row according to the property's formatter class * * @return the alignment definitions of all table cells in one row according to the property's formatter class */ public List<String> getTableCellAlignment() { List<String> cellWidthList = new ArrayList<String>(); List<Class<? extends Formatter>> numberFormatters = this.getNumberFormatters(); for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) { String attributeName = entry.getKey(); boolean isNumber = false; if (!attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) { try { Class<? extends Formatter> formatterClass = this .retrievePropertyFormatterClass(dataDictionaryBusinessObjectClass, attributeName); isNumber = numberFormatters.contains(formatterClass); } catch (Exception e) { throw new RuntimeException("Failed getting propertyName=" + attributeName + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e); } } cellWidthList.add(isNumber ? RIGHT_ALIGNMENT : LEFT_ALIGNMENT); } return cellWidthList; } // put empty strings into the table cell values if the values are not enough to feed the table protected void paddingTableCellValues(int numberOfCell, List<String> tableCellValues) { int reminder = columnCount - numberOfCell % columnCount; if (reminder < columnCount) { List<String> paddingObject = new ArrayList<String>(reminder); for (int index = 0; index < reminder; index++) { paddingObject.add(StringUtils.EMPTY); } tableCellValues.addAll(paddingObject); } } /** * get formatter classes defined for numbers * * @return the formatter classes defined for numbers */ protected List<Class<? extends Formatter>> getNumberFormatters() { List<Class<? extends Formatter>> numberFormatters = new ArrayList<Class<? extends Formatter>>(); numberFormatters.add(BigDecimalFormatter.class); numberFormatters.add(CurrencyFormatter.class); numberFormatters.add(KualiIntegerCurrencyFormatter.class); numberFormatters.add(PercentageFormatter.class); numberFormatters.add(IntegerFormatter.class); numberFormatters.add(LongFormatter.class); return numberFormatters; } /** * Sets the minimumMessageLength * * @param minimumMessageLength The minimumMessageLength to set. */ public void setMinimumMessageLength(int minimumMessageLength) { this.minimumMessageLength = minimumMessageLength; } /** * Sets the messageLabel * * @param messageLabel The messageLabel to set. */ public void setMessageLabel(String messageLabel) { this.messageLabel = messageLabel; } /** * Sets the dataDictionaryBusinessObjectClass * * @param dataDictionaryBusinessObjectClass The dataDictionaryBusinessObjectClass to set. */ public void setDataDictionaryBusinessObjectClass( Class<? extends BusinessObject> dataDictionaryBusinessObjectClass) { this.dataDictionaryBusinessObjectClass = dataDictionaryBusinessObjectClass; } /** * Sets the orderedPropertyNameToHeaderLabelMap * * @param orderedPropertyNameToHeaderLabelMap The orderedPropertyNameToHeaderLabelMap to set. */ public void setOrderedPropertyNameToHeaderLabelMap(Map<String, String> orderedPropertyNameToHeaderLabelMap) { this.orderedPropertyNameToHeaderLabelMap = orderedPropertyNameToHeaderLabelMap; } /** * Sets the dataDictionaryService * * @param dataDictionaryService The dataDictionaryService to set. */ public void setDataDictionaryService(DataDictionaryService dataDictionaryService) { this.dataDictionaryService = dataDictionaryService; } /** * Sets the columnCount attribute value. * * @param columnCount The columnCount to set. */ public void setColumnCount(int columnCount) { this.columnCount = columnCount; } /** * Sets the columnSpanDefinition attribute value. * * @param columnSpanDefinition The columnSpanDefinition to set. */ public void setColumnSpanDefinition(Map<String, Integer> columnSpanDefinition) { this.columnSpanDefinition = columnSpanDefinition; } }