KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > jaspersoft > jasperserver > war > OlapPrint


1 /*
2  * Copyright (C) 2006 JasperSoft http://www.jaspersoft.com
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed WITHOUT ANY WARRANTY; and without the
10  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  * See the GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, see http://www.gnu.org/licenses/gpl.txt
15  * or write to:
16  *
17  * Free Software Foundation, Inc.,
18  * 59 Temple Place - Suite 330,
19  * Boston, MA USA 02111-1307
20  */
21
22 package com.jaspersoft.jasperserver.war;
23
24 import java.io.ByteArrayInputStream JavaDoc;
25 import java.io.ByteArrayOutputStream JavaDoc;
26 import java.io.IOException JavaDoc;
27 import java.io.OutputStream JavaDoc;
28 import java.io.PrintWriter JavaDoc;
29 import java.io.StringWriter JavaDoc;
30 import java.util.HashMap JavaDoc;
31 import java.util.Iterator JavaDoc;
32 import java.util.Map JavaDoc;
33
34 import javax.servlet.ServletConfig JavaDoc;
35 import javax.servlet.ServletException JavaDoc;
36 import javax.servlet.http.HttpServlet JavaDoc;
37 import javax.servlet.http.HttpServletRequest JavaDoc;
38 import javax.servlet.http.HttpServletResponse JavaDoc;
39 import javax.servlet.http.HttpSession JavaDoc;
40 import javax.xml.transform.Transformer JavaDoc;
41 import javax.xml.transform.dom.DOMSource JavaDoc;
42 import javax.xml.transform.stream.StreamResult JavaDoc;
43
44 import org.apache.avalon.framework.logger.NullLogger;
45 import org.apache.commons.logging.Log;
46 import org.apache.commons.logging.LogFactory;
47 import org.apache.fop.apps.Driver;
48 import org.apache.fop.apps.FOPException;
49 import org.w3c.dom.Document JavaDoc;
50 import org.xml.sax.InputSource JavaDoc;
51
52 import com.tonbeller.jpivot.chart.ChartComponent;
53 import com.tonbeller.jpivot.print.PrintComponent;
54 import com.tonbeller.jpivot.table.TableComponent;
55 import com.tonbeller.wcf.component.RendererParameters;
56 import com.tonbeller.wcf.controller.RequestContext;
57 import com.tonbeller.wcf.controller.RequestContextFactoryFinder;
58 import com.tonbeller.wcf.utils.XmlUtils;
59
60 /**
61  *
62  * Based on the PrintServlet in JPivot. Download Excel and PDF files
63  * based on the current OLAP view
64  *
65  * @author swood
66  *
67  */
68 public class OlapPrint extends HttpServlet JavaDoc {
69     
70     private static final Log logger = LogFactory.getLog(OlapPrint.class);
71     
72     private static int XLS = 0;
73     private static int PDF = 1;
74     String JavaDoc filename;
75
76     /**
77      *
78      */
79     public OlapPrint() {
80         super();
81     }
82
83       /** Initializes the servlet.
84        */
85       public void init(ServletConfig JavaDoc config) throws ServletException JavaDoc {
86         super.init(config);
87         /*
88          * TODO Add init parameters for:
89          * ChartServlet path,
90          * Excel XSL and content type,
91          * PDF XSL and content type
92          */
93       }
94
95       /** Destroys the servlet.
96        */
97       public void destroy() {
98
99       }
100
101       /** Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
102        *
103        * @param request servlet request
104        * @param response servlet response
105        */
106
107       protected void processRequest(RequestContext context) throws ServletException JavaDoc, IOException JavaDoc {
108         HttpServletRequest JavaDoc request = context.getRequest();
109         HttpServletResponse JavaDoc response = context.getResponse();
110         HttpSession JavaDoc session = request.getSession();
111
112         String JavaDoc type = request.getParameter("type");
113         int identifiedType = -1;
114         boolean xslCache = true;
115         
116         String JavaDoc view = request.getParameter("view");
117         
118         if (view == null || type == null) {
119             throw new ServletException JavaDoc("view and type parameters not supplied");
120         }
121         
122         try {
123             String JavaDoc xslUri = null;
124             if (type.equalsIgnoreCase("XLS")) {
125               xslUri = "/WEB-INF/jpivot/table/xls_mdxtable.xsl";
126               RendererParameters.setParameter(context.getRequest(), "mode", "excel", "request");
127               response.setContentType("application/vnd.ms-excel");
128               filename = "xls_export.xls";
129               identifiedType = XLS;
130             } else if (type.equalsIgnoreCase("PDF")) {
131               xslUri = "/WEB-INF/jpivot/table/fo_mdxtable.xsl";
132               RendererParameters.setParameter(context.getRequest(), "mode", "print", "request");
133               response.setContentType("application/pdf");
134               filename = "xls_export.pdf";
135               identifiedType = PDF;
136             } else {
137                 throw new ServletException JavaDoc("Unknown file type: " + type);
138             }
139
140               
141             // Get references to needed elements. We expect them to be in the current
142 // session
143
144             String JavaDoc tableRef = view + "/table";
145             String JavaDoc chartRef = view + "/chart";
146             String JavaDoc printRef = view + "/print";
147
148             // get TableComponent
149 TableComponent table = (TableComponent) context.getModelReference(tableRef);
150             // only proceed if table component exists
151 if (table == null) {
152                 return;
153             }
154               
155             Map JavaDoc parameters = getPrintParameters(printRef, context);
156             parameters.putAll(getChartParameters(chartRef, request));
157
158             //parameters.put("message",table.getReportTitle());
159 // add "context" and "renderId" to parameter map
160
161             //parameters.put("renderId", renderId);
162 parameters.put("context", context.getRequest().getContextPath());
163
164             // Some FOP-PDF versions require a complete URL, not a path
165 //parameters.put("contextUrl", createContextURLValue(context));
166
167             // Get table rendered as XML
168
169             StringWriter JavaDoc sw = getRenderedTableDOM(table, parameters, session, context, xslUri, xslCache);
170
171             OutputStream JavaDoc outStream = response.getOutputStream();
172             PrintWriter JavaDoc out = new PrintWriter JavaDoc(outStream);
173             
174             // set up filename for download.
175 response.setHeader("Content-Disposition", "attachment; filename=" + filename);
176
177             // if this is XLS, then we are done, so output xml file.
178 if (identifiedType == XLS) {
179                 logger.debug("Creating XLS");
180                 response.setContentLength(sw.toString().length());
181                 out.write(sw.toString());
182                 RendererParameters.removeParameter(context.getRequest(), "mode", "excel", "request");
183             } else {
184                 // if this is PDF, then need to generate PDF from the FO xml
185 logger.debug("Creating PDF");
186                 try {
187                     ByteArrayInputStream JavaDoc bain = new ByteArrayInputStream JavaDoc(sw.toString()
188                         .getBytes("UTF-8"));
189                     ByteArrayOutputStream JavaDoc baout = new ByteArrayOutputStream JavaDoc(16384);
190                     // process FO to PDF
191 convertFO2PDF(bain, baout);
192                     final byte[] content = baout.toByteArray();
193                     response.setContentLength(content.length);
194                     outStream.write(content);
195                     RendererParameters
196                             .removeParameter(context.getRequest(), "mode", "print", "request");
197                 } catch (Exception JavaDoc e) {
198                     logger.error(e);
199                 }
200             }
201             
202             //close output streams
203 out.flush();
204             out.close();
205             outStream.flush();
206             
207         } catch (Exception JavaDoc e) {
208             logger.error(e);
209             throw new ServletException JavaDoc(e);
210         }
211       }
212
213     /**
214      * Set parameters for printing based on defaults + settings through the
215      * print parameters form
216      *
217      * @param printRef
218      * @param context
219      * @return
220      */
221     private Map JavaDoc getPrintParameters(String JavaDoc printRef, RequestContext context) {
222         Map JavaDoc parameters = new HashMap JavaDoc();
223           
224         // add parameters from printConfig
225 PrintComponent printConfig = (PrintComponent) context.getModelReference(printRef);
226         if (printConfig == null) {
227             return parameters;
228         }
229         if (printConfig.isSetTableWidth()) {
230             parameters.put(printConfig.PRINT_TABLE_WIDTH, new Double JavaDoc(printConfig
231                   .getTableWidth()));
232         }
233         if (printConfig.getReportTitle().trim().length() != 0) {
234             parameters.put(printConfig.PRINT_TITLE, printConfig.getReportTitle().trim());
235         }
236         parameters.put(printConfig.PRINT_PAGE_ORIENTATION, printConfig.getPageOrientation());
237         parameters.put(printConfig.PRINT_PAPER_TYPE, printConfig.getPaperType());
238         if (printConfig.getPaperType().equals("custom")) {
239             parameters
240                   .put(printConfig.PRINT_PAGE_WIDTH, new Double JavaDoc(printConfig.getPageWidth()));
241             parameters.put(printConfig.PRINT_PAGE_HEIGHT, new Double JavaDoc(printConfig
242                   .getPageHeight()));
243         }
244         parameters.put(printConfig.PRINT_CHART_PAGEBREAK, new Boolean JavaDoc(printConfig
245                   .isChartPageBreak()));
246
247         return parameters;
248       }
249
250     /**
251      * Set parameters to include the chart in the printed Excel or PDF
252      *
253      * @param chartRef
254      * @param request
255      * @return
256      */
257     private Map JavaDoc getChartParameters(String JavaDoc chartRef, HttpServletRequest JavaDoc request) {
258           Map JavaDoc parameters = new HashMap JavaDoc();
259           
260           // add parameters and image from chart if visible
261 ChartComponent chart = (ChartComponent) request.getSession().getAttribute(chartRef);
262           if (chart == null || !chart.isVisible()) {
263               return parameters;
264           }
265
266           String JavaDoc host = request.getServerName();
267           int port = request.getServerPort();
268           String JavaDoc location = request.getContextPath();
269           String JavaDoc scheme = request.getScheme();
270
271           String JavaDoc chartServlet = scheme + "://" + host + ":" + port + location + "/GetChart";
272           parameters.put("chartimage", chartServlet + "?filename=" + chart.getFilename());
273           parameters.put("chartheight", new Integer JavaDoc(chart.getChartHeight()));
274           parameters.put("chartwidth", new Integer JavaDoc(chart.getChartWidth()));
275           return parameters;
276     }
277       
278     /**
279      * Get the XML rendition of the table component based on the given parameters
280      *
281      * @param table
282      * @param parameters
283      * @param session
284      * @param context
285      * @param xslUri
286      * @param xslCache
287      * @return
288      * @throws Exception
289      */
290     private StringWriter JavaDoc getRenderedTableDOM(TableComponent table,
291                                                 Map JavaDoc parameters,
292                                                 HttpSession JavaDoc session,
293                                                 RequestContext context,
294                                                 String JavaDoc xslUri,
295                                                 boolean xslCache) throws Exception JavaDoc {
296           
297           table.setDirty(true);
298           Document JavaDoc document = table.render(context);
299           table.setDirty(true);
300
301           DOMSource JavaDoc source = new DOMSource JavaDoc(document);
302           // set up xml transformation
303 Transformer JavaDoc transformer = XmlUtils.getTransformer(session, xslUri, xslCache);
304           for (Iterator JavaDoc it = parameters.keySet().iterator(); it.hasNext();) {
305             String JavaDoc name = (String JavaDoc) it.next();
306             Object JavaDoc value = parameters.get(name);
307             transformer.setParameter(name, value);
308           }
309           StringWriter JavaDoc sw = new StringWriter JavaDoc();
310           StreamResult JavaDoc result = new StreamResult JavaDoc(sw);
311           //do transform
312 transformer.transform(source, result);
313           sw.flush();
314           
315           return sw;
316
317       }
318     
319       /**
320        * converts FO xml into PDF using the FOP processor
321        */
322       public void convertFO2PDF(ByteArrayInputStream JavaDoc bain, ByteArrayOutputStream JavaDoc baout)
323           throws IOException JavaDoc, FOPException {
324
325         logger.debug("Construct driver");
326         Driver driver = new Driver();
327         driver.setLogger(new NullLogger());
328
329         logger.debug("Setup Renderer (output format)");
330         driver.setRenderer(Driver.RENDER_PDF);
331
332         driver.setOutputStream(baout);
333         logger.debug("Setup input");
334         driver.setInputSource(new InputSource JavaDoc(bain));
335
336         logger.debug("Process FO");
337         driver.run();
338         logger.debug("PDF file generation completed");
339       }
340
341       /** Handles the HTTP <code>GET</code> method.
342        * @param request servlet request
343        * @param response servlet response
344        */
345       protected void doGet(HttpServletRequest JavaDoc request, HttpServletResponse JavaDoc response)
346           throws ServletException JavaDoc, IOException JavaDoc {
347         doPost(request, response);
348       }
349
350       /** Handles the HTTP <code>POST</code> method.
351        * @param request servlet request
352        * @param response servlet response
353        */
354       protected void doPost(HttpServletRequest JavaDoc request, HttpServletResponse JavaDoc response)
355           throws ServletException JavaDoc, IOException JavaDoc {
356         RequestContext context = RequestContextFactoryFinder.createContext(request, response, true);
357         try {
358           processRequest(context);
359         } finally {
360           context.invalidate();
361         }
362       }
363
364       /** Returns a short description of the servlet.
365        */
366       public String JavaDoc getServletInfo() {
367         return "Export OLAP table to Excel or PDF";
368       }
369
370 }
371
Popular Tags