KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > openi > report > EnhancedPrintServlet


1 /*********************************************************************************
2  * The contents of this file are subject to the OpenI Public License Version 1.0
3  * ("License"); You may not use this file except in compliance with the
4  * License. You may obtain a copy of the License at
5  * http://www.openi.org/docs/LICENSE.txt
6  *
7  * Software distributed under the License is distributed on an "AS IS" basis,
8  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
9  * the specific language governing rights and limitations under the License.
10  *
11  * The Original Code is: OpenI Open Source
12  *
13  * The Initial Developer of the Original Code is Loyalty Matrix, Inc.
14  * Portions created by Loyalty Matrix, Inc. are
15  * Copyright (C) 2005 Loyalty Matrix, Inc.; All Rights Reserved.
16  *
17  * Contributor(s): ______________________________________.
18  *
19  ********************************************************************************/
20 package org.openi.report;
21
22 import com.tonbeller.jpivot.chart.ChartComponent;
23 import com.tonbeller.jpivot.print.PrintComponent;
24 import com.tonbeller.jpivot.table.TableComponent;
25 import com.tonbeller.wcf.component.RendererParameters;
26 import com.tonbeller.wcf.controller.RequestContext;
27 import com.tonbeller.wcf.controller.RequestContextFactoryFinder;
28 import com.tonbeller.wcf.utils.XmlUtils;
29 import org.apache.fop.apps.Driver;
30 import org.apache.fop.apps.FOPException;
31 import org.openi.analysis.Analysis;
32 import org.openi.project.Project;
33 import org.openi.project.ProjectContext;
34 import org.w3c.dom.Document JavaDoc;
35 import org.xml.sax.InputSource JavaDoc;
36 import java.io.ByteArrayInputStream JavaDoc;
37 import java.io.ByteArrayOutputStream JavaDoc;
38 import java.io.IOException JavaDoc;
39 import java.io.OutputStream JavaDoc;
40 import java.io.PrintWriter JavaDoc;
41 import java.io.StringWriter JavaDoc;
42 import java.util.HashMap JavaDoc;
43 import java.util.Iterator JavaDoc;
44 import java.util.Map JavaDoc;
45 import javax.servlet.ServletConfig JavaDoc;
46 import javax.servlet.ServletException JavaDoc;
47 import javax.servlet.http.HttpServlet JavaDoc;
48 import javax.servlet.http.HttpServletRequest JavaDoc;
49 import javax.servlet.http.HttpServletResponse JavaDoc;
50 import javax.servlet.http.HttpSession JavaDoc;
51 import javax.xml.transform.Transformer JavaDoc;
52 import javax.xml.transform.dom.DOMSource JavaDoc;
53 import javax.xml.transform.stream.StreamResult JavaDoc;
54
55
56 public class EnhancedPrintServlet extends HttpServlet JavaDoc {
57     private static final int XML = 0;
58     private static final int PDF = 1;
59     String JavaDoc basePath;
60     String JavaDoc filename;
61
62     /** Initializes the servlet.
63      */
64     public void init(ServletConfig JavaDoc config) throws ServletException JavaDoc {
65         super.init(config);
66     }
67
68     /** Destroys the servlet.
69      */
70     public void destroy() {
71     }
72
73     /** Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
74      * @param request servlet request
75      * @param response servlet response
76      */
77     protected void processRequest(RequestContext context)
78         throws ServletException JavaDoc, IOException JavaDoc {
79         HttpServletRequest JavaDoc request = context.getRequest();
80         HttpServletResponse JavaDoc response = context.getResponse();
81
82         if ((request.getParameter("cube") != null)
83                 && (request.getParameter("type") != null)) {
84             try {
85                 String JavaDoc xslUri = null;
86                 int type = Integer.parseInt(request.getParameter("type"));
87
88                 switch (type) {
89                 case XML:
90                     xslUri = "/WEB-INF/openi/table/xls_mdxtable.xsl";
91                     RendererParameters.setParameter(context.getRequest(),
92                         "mode", "excel", "request");
93                     response.setContentType("application/vnd.ms-excel");
94                     filename = "xls_export.xls";
95
96                     break;
97
98                 case PDF:
99                     xslUri = "/WEB-INF/openi/table/fo_mdxtable.xsl";
100                     RendererParameters.setParameter(context.getRequest(),
101                         "mode", "print", "request");
102                     response.setContentType("application/pdf");
103                     filename = "xls_export.pdf";
104
105                     break;
106                 }
107
108                 if (xslUri != null) {
109                     boolean xslCache = true;
110
111                     // get references to needed elements
112 String JavaDoc tableRef = "table" + request.getParameter("cube");
113                     String JavaDoc chartRef = "chart" + request.getParameter("cube");
114                     String JavaDoc printRef = "print" + request.getParameter("cube");
115
116                     Map JavaDoc parameters = new HashMap JavaDoc();
117
118                     OutputStream JavaDoc outStream = response.getOutputStream();
119                     PrintWriter JavaDoc out = new PrintWriter JavaDoc(outStream);
120                     HttpSession JavaDoc session = request.getSession();
121                     // set up filename for download.
122 response.setHeader("Content-Disposition",
123                         "attachment; filename=" + filename);
124
125                     // get TableComponent
126 TableComponent table = (TableComponent) context
127                             .getModelReference(tableRef);
128
129                         // only proceed if table component exists
130 if (table != null) {
131                             // add parameters from printConfig
132 PrintComponent printConfig = (PrintComponent) context
133                                 .getModelReference(printRef);
134
135                             if (printConfig != null) {
136                                 if (printConfig.isSetTableWidth()) {
137                                     parameters.put(printConfig.PRINT_TABLE_WIDTH,
138                                         new Double JavaDoc(printConfig.getTableWidth()));
139                                 }
140
141                                 // if (printConfig.getReportTitle().trim().length() != 0) {
142 // parameters.put(printConfig.PRINT_TITLE, printConfig.getReportTitle().trim());
143 // }
144 parameters.put(printConfig.PRINT_PAGE_ORIENTATION,
145                                     printConfig.getPageOrientation());
146                                 parameters.put(printConfig.PRINT_PAPER_TYPE,
147                                     printConfig.getPaperType());
148
149                                 if (printConfig.getPaperType().equals("custom")) {
150                                     parameters.put(printConfig.PRINT_PAGE_WIDTH,
151                                         new Double JavaDoc(printConfig.getPageWidth()));
152                                     parameters.put(printConfig.PRINT_PAGE_HEIGHT,
153                                         new Double JavaDoc(printConfig.getPageHeight()));
154                                 }
155
156                                 parameters.put(printConfig.PRINT_CHART_PAGEBREAK,
157                                     new Boolean JavaDoc(printConfig.isChartPageBreak()));
158                             }
159
160                             // add parameters and image from chart if visible
161 ChartComponent chart = (ChartComponent) request.getSession()
162                                                                            .getAttribute(chartRef);
163
164                             if ((chart != null) && chart.isVisible()) {
165                                 String JavaDoc host = request.getServerName();
166                                 int port = request.getServerPort();
167                                 String JavaDoc location = request.getContextPath();
168
169                                 String JavaDoc chartServlet = "http://" + host + ":"
170                                     + port + location + "/GetChart";
171                                 parameters.put("chartimage",
172                                     chartServlet + "?filename="
173                                     + chart.getFilename());
174                                 parameters.put("chartheight",
175                                     new Integer JavaDoc(chart.getChartHeight()));
176                                 parameters.put("chartwidth",
177                                     new Integer JavaDoc(chart.getChartWidth()));
178                             }
179
180                             Project project = ((ProjectContext) session
181                                     .getAttribute("projectContext")).getProject();
182                                 String JavaDoc headerText;
183                                 headerText = project.getProjectName();
184                                 headerText += " - ";
185                                 headerText += ((Analysis) session.getAttribute(
186                                     "analysis01")).getAnalysisTitle();
187                                 parameters.put("pageHeaderText", headerText);
188                                 parameters.put(printConfig.PRINT_TITLE,
189                                     headerText);
190                                 // parameters.put("pageFooterText",project.getReportFooter()!=null?project.getReportFooter():"");
191
192                                 //parameters.put("message",table.getReportTitle());
193 // add "context" and "renderId" to parameter map
194 parameters.put("context",
195                                     context.getRequest().getContextPath());
196
197                                 // Some FOP-PDF versions require a complete URL, not a path
198 //parameters.put("contextUrl", createContextURLValue(context));
199 table.setDirty(true);
200
201                                 Document JavaDoc document = table.render(context);
202                                 table.setDirty(true);
203
204                                 DOMSource JavaDoc source = new DOMSource JavaDoc(document);
205
206                                 // set up xml transformation
207 Transformer JavaDoc transformer = XmlUtils
208                                         .getTransformer(session, xslUri,
209                                             xslCache);
210
211                                     for (Iterator JavaDoc it = parameters.keySet()
212                                                                  .iterator();
213                                             it.hasNext();) {
214                                         String JavaDoc name = (String JavaDoc) it.next();
215                                         Object JavaDoc value = parameters.get(name);
216                                         transformer.setParameter(name, value);
217                                     }
218
219                                     StringWriter JavaDoc sw = new StringWriter JavaDoc();
220                                     StreamResult JavaDoc result = new StreamResult JavaDoc(sw);
221                                     //do transform
222 transformer.transform(source, result);
223                                     sw.flush();
224
225                                     // if thisis XML, then we are done, so output xml file.
226 if (type == XML) {
227                                         System.out.println("Writing XLS");
228                                         response.setContentLength(sw.toString()
229                                                                     .length());
230                                         out.write(sw.toString());
231                                         RendererParameters.removeParameter(context
232                                             .getRequest(), "mode", "excel",
233                                             "request");
234
235                                         // process FO to PDF
236 } else {
237                                         // if this is PDF, then need to generate PDF from the FO xml
238 System.out.println("Creating PDF!");
239
240                                         try {
241                                             ByteArrayInputStream JavaDoc bain = new ByteArrayInputStream JavaDoc(sw.toString()
242                                                                                                    .getBytes("UTF-8"));
243                                             ByteArrayOutputStream JavaDoc baout = new ByteArrayOutputStream JavaDoc(16384);
244                                             convertFO2PDF(bain, baout);
245
246                                             final byte[] content = baout
247                                                     .toByteArray();
248                                                 response.setContentLength(content.length);
249                                                 outStream.write(content);
250                                                 RendererParameters
251                                                     .removeParameter(context
252                                                             .getRequest(),
253                                                             "mode", "print",
254                                                             "request");
255
256                                                         //convertXML2PDF(document.toString(), xslUri, outStream);
257 } catch (Exception JavaDoc e) {
258                                                         e.printStackTrace();
259                                                     }
260                                                 }
261
262                                                 //close output streams
263 out.flush();
264                                                 out.close();
265                                                 outStream.flush();
266                                             }
267                                         }
268                                     } catch (Exception JavaDoc e) {
269                                         e.printStackTrace();
270                                     }
271                                 }
272                             }
273
274                             /**
275                              * converts FO xml into PDF using the FOP processor
276                              */
277                             public void convertFO2PDF(
278                                 ByteArrayInputStream JavaDoc bain,
279                                 ByteArrayOutputStream JavaDoc baout)
280                                 throws IOException JavaDoc, FOPException {
281                                 System.out.println("Construct driver");
282
283                                 Driver driver = new Driver();
284
285                                 System.out.println(
286                                     "Setup Renderer (output format)");
287                                 driver.setRenderer(Driver.RENDER_PDF);
288
289                                 try {
290                                     driver.setOutputStream(baout);
291                                     System.out.println("Setup input");
292
293                                     try {
294                                         driver.setInputSource(new InputSource JavaDoc(
295                                                 bain));
296
297                                         System.out.println("Process FO");
298                                         driver.run();
299                                         System.out.println(
300                                             "PDF file generation completed");
301                                     } finally {
302                                     }
303                                 } finally {
304                                 }
305                             }
306
307                             /** Handles the HTTP <code>GET</code> method.
308                              * @param request servlet request
309                              * @param response servlet response
310                              */
311                             protected void doGet(HttpServletRequest JavaDoc request,
312                                 HttpServletResponse JavaDoc response)
313                                 throws ServletException JavaDoc, IOException JavaDoc {
314                                 doPost(request, response);
315                             }
316
317                             /** Handles the HTTP <code>POST</code> method.
318                              * @param request servlet request
319                              * @param response servlet response
320                              */
321                             protected void doPost(HttpServletRequest JavaDoc request,
322                                 HttpServletResponse JavaDoc response)
323                                 throws ServletException JavaDoc, IOException JavaDoc {
324                                 RequestContext context = RequestContextFactoryFinder
325                                     .createContext(request, response, true);
326
327                                 try {
328                                     processRequest(context);
329                                 } finally {
330                                     context.invalidate();
331                                 }
332                             }
333
334                             /** Returns a short description of the servlet.
335                              */
336                             public String JavaDoc getServletInfo() {
337                                 return "Export OLAP table";
338                             }
339                         }
340
Popular Tags