001: /*
002: * Copyright 2006-2007 Luca Garulli (luca.garulli@assetdata.it)
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License"); you may not
005: * use this file except in compliance with the License. You may obtain a copy of
006: * the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
012: * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
013: * License for the specific language governing permissions and limitations under
014: * the License.
015: */
016: package org.romaframework.aspect.reporting.jr;
017:
018: import java.io.ByteArrayOutputStream;
019: import java.io.IOException;
020: import java.util.Collection;
021:
022: import net.sf.jasperreports.engine.JRAbstractExporter;
023: import net.sf.jasperreports.engine.JRException;
024: import net.sf.jasperreports.engine.JRExporterParameter;
025: import net.sf.jasperreports.engine.JasperExportManager;
026: import net.sf.jasperreports.engine.JasperPrint;
027: import net.sf.jasperreports.engine.export.JRCsvExporter;
028: import net.sf.jasperreports.engine.export.JRHtmlExporter;
029: import net.sf.jasperreports.engine.export.JRRtfExporter;
030: import net.sf.jasperreports.engine.export.JRXlsExporter;
031:
032: import org.apache.commons.logging.Log;
033: import org.apache.commons.logging.LogFactory;
034: import org.romaframework.aspect.reporting.ReportingAspect;
035: import org.romaframework.aspect.reporting.ReportingAspectAbstract;
036: import org.romaframework.aspect.reporting.ReportingConstants;
037: import org.romaframework.aspect.reporting.ReportingException;
038: import org.romaframework.aspect.reporting.feature.ReportingClassFeatures;
039: import org.romaframework.aspect.reporting.jr.component.ObjectComponentJr;
040: import org.romaframework.aspect.reporting.jr.template.TemplateManager;
041: import org.romaframework.core.Utility;
042: import org.romaframework.core.flow.ObjectContext;
043: import org.romaframework.core.schema.SchemaClassDefinition;
044: import org.romaframework.core.schema.SchemaClassResolver;
045: import org.romaframework.core.schema.SchemaFeatures;
046: import org.romaframework.core.schema.SchemaManager;
047: import org.romaframework.core.util.DynaBean;
048:
049: /**
050: * Reporting implementation using JasperReports tool.
051: *
052: * @author Giordano Maestro (giordano.maestro@assetdata.it)
053: *
054: */
055: public class JRReportingAspect extends ReportingAspectAbstract {
056:
057: @Override
058: public void startup() {
059: super .startup();
060: ObjectContext.getInstance().getComponent(
061: SchemaClassResolver.class).addDomainPackage(
062: Utility.getRomaAspectPackage(aspectName() + ".jr"));
063: ObjectContext.getInstance().getComponent(
064: SchemaClassResolver.class)
065: .addDomainPackage(
066: Utility.getRomaAspectPackage(aspectName()
067: + ".jr.view"));
068: }
069:
070: private static final String UTF_8 = "UTF-8";
071: protected final Log log = LogFactory.getLog("JR.REPORTING");
072:
073: public byte[] render(Object iToRender) {
074: return render(iToRender, null);
075: }
076:
077: public byte[] render(Object iToRender, String iRenderType) {
078: final long start = System.currentTimeMillis();
079:
080: try {
081: final SchemaFeatures schemaObject = ObjectContext
082: .getInstance().getComponent(SchemaManager.class)
083: .getClassInfo(iToRender.getClass().getSimpleName());
084: // Create the report
085: final ObjectComponentJr jrReport = new ObjectComponentJr(
086: null, schemaObject);
087: jrReport.generateDesign();
088: // Get the printer
089: final JasperPrint jPrint = jrReport.getPrinter(iToRender);
090:
091: final long time = System.currentTimeMillis() - start;
092: log.debug("Report " + schemaObject + " exported. Millis: "
093: + time);
094: return exportDocument(iRenderType, schemaObject, jPrint);
095: } catch (final JRException e) {
096: throw new RuntimeException(e);
097: }
098:
099: }
100:
101: private byte[] exportDocument(String iRenderType,
102: SchemaFeatures schemaObject, JasperPrint jPrint)
103: throws JRException {
104: final DynaBean classFeatures = schemaObject
105: .getFeatures(ReportingAspect.ASPECT_NAME);
106:
107: String documentType;
108: if (iRenderType == null) {
109: documentType = (String) classFeatures
110: .getAttribute(ReportingClassFeatures.DOCUMENT_TYPE);
111: } else {
112: documentType = iRenderType;
113: }
114: documentType = documentType.toLowerCase();
115: if (ReportingConstants.DOCUMENT_TYPE_HTML.equals(documentType)) {
116: final JRHtmlExporter exporter = new JRHtmlExporter();
117: return export(jPrint, exporter);
118:
119: } else if (ReportingConstants.DOCUMENT_TYPE_CSV
120: .equals(documentType)) {
121: final JRCsvExporter exporter = new JRCsvExporter();
122: return export(jPrint, exporter);
123:
124: } else if (ReportingConstants.DOCUMENT_TYPE_EXCEL
125: .equals(documentType)) {
126: final JRXlsExporter exporter = new JRXlsExporter();
127: return export(jPrint, exporter);
128: } else if (ReportingConstants.DOCUMENT_TYPE_XML
129: .equals(documentType)) {
130: return JasperExportManager.exportReportToXml(jPrint)
131: .getBytes();
132: } else if (ReportingConstants.DOCUMENT_TYPE_DOC
133: .equals(documentType)) {
134: final JRRtfExporter exporter = new JRRtfExporter();
135: return export(jPrint, exporter);
136: }
137:
138: else {
139: return JasperExportManager.exportReportToPdf(jPrint);
140: }
141: }
142:
143: private byte[] export(JasperPrint jPrint,
144: JRAbstractExporter exporter) throws JRException {
145:
146: final ByteArrayOutputStream out = new ByteArrayOutputStream();
147: exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, out);
148: exporter.setParameter(JRExporterParameter.JASPER_PRINT, jPrint);
149: exporter.setParameter(JRExporterParameter.CHARACTER_ENCODING,
150: UTF_8);
151:
152: try {
153: out.close();
154: exporter.exportReport();
155: } catch (final IOException e) {
156: throw new RuntimeException(e);
157: }
158: return out.toByteArray();
159: }
160:
161: public byte[] renderCollection(Collection<?> collection) {
162: return renderCollection(collection, null);
163: }
164:
165: public byte[] renderCollection(Collection<?> collectionToRender,
166: String iRenderType) {
167: final long start = System.currentTimeMillis();
168: if (collectionToRender != null
169: && collectionToRender.size() == 0) {
170: return new byte[0];
171: }
172: try {
173: SchemaClassDefinition schemaObject = null;
174: ObjectComponentJr jrReport = null;
175: for (final Object iToRender : collectionToRender) {
176: if (schemaObject == null) {
177: schemaObject = ObjectContext.getInstance()
178: .getComponent(SchemaManager.class)
179: .getClassInfo(
180: iToRender.getClass()
181: .getSimpleName());
182: }
183: // Create the report
184:
185: jrReport = new ObjectComponentJr(null, schemaObject);
186: jrReport.generateDesign();
187: break;
188: }
189:
190: final JasperPrint jPrint = jrReport
191: .getCollectionPrinter(collectionToRender);
192:
193: // Get the printer
194:
195: final long time = System.currentTimeMillis() - start;
196: log.debug("Report exported. Sec: " + time);
197: return exportDocument(iRenderType, schemaObject, jPrint);
198: } catch (final Exception e) {
199: throw new RuntimeException(e);
200: }
201: }
202:
203: @Override
204: protected void refresh(SchemaClassDefinition updatedClass) {
205: ObjectContext.getInstance().getComponent(TemplateManager.class)
206: .removeDesign(updatedClass.getSchemaClass().getName());
207: }
208:
209: public void createTemplate(SchemaClassDefinition schemaClass)
210: throws ReportingException {
211:
212: try {
213: ObjectContext.getInstance().getComponent(
214: TemplateManager.class).removeDesign(
215: schemaClass.getSchemaClass().getName());
216: final ObjectComponentJr component = new ObjectComponentJr(
217: null, schemaClass);
218: component.generateDesign();
219: component.saveTemplate();
220:
221: } catch (final JRException e) {
222: throw new ReportingException(e);
223: }
224:
225: }
226:
227: public String[] getSupportedTypes() {
228: final String[] result = { "CSV", "PDF", "XML", "XLS" };
229: return result;
230: }
231:
232: public String getDocumentType(String renderType) {
233: if (renderType == null)
234: return "application/pdf";
235: renderType = renderType.toLowerCase();
236: if (renderType.equals(ReportingConstants.DOCUMENT_TYPE_CSV)) {
237: return "text/plain";
238: } else if (renderType
239: .equals(ReportingConstants.DOCUMENT_TYPE_EXCEL)) {
240: return "application/ms-excel";
241: } else if (renderType
242: .equals(ReportingConstants.DOCUMENT_TYPE_XML)) {
243: return "text/html";
244: } else {
245: return "application/pdf";
246: }
247: }
248:
249: }
|