KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > efs > openreports > services > ReportServiceImpl


1 /*
2  * Copyright (C) 2006 Erik Swenson - erik@oreports.com
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the Free
6  * Software Foundation; either version 2 of the License, or (at your option)
7  * any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16  * Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  */

19
20 package org.efs.openreports.services;
21
22 import java.io.File JavaDoc;
23 import java.util.Date JavaDoc;
24 import java.util.HashMap JavaDoc;
25 import java.util.Map JavaDoc;
26 import java.util.StringTokenizer JavaDoc;
27
28 import org.apache.commons.lang.ArrayUtils;
29 import org.apache.log4j.Logger;
30 import org.efs.openreports.ORStatics;
31 import org.efs.openreports.engine.ReportEngine;
32 import org.efs.openreports.engine.input.ReportEngineInput;
33 import org.efs.openreports.engine.output.ReportEngineOutput;
34 import org.efs.openreports.objects.Report;
35 import org.efs.openreports.objects.ReportLog;
36 import org.efs.openreports.objects.ReportSchedule;
37 import org.efs.openreports.objects.ReportUser;
38 import org.efs.openreports.providers.DataSourceProvider;
39 import org.efs.openreports.providers.DirectoryProvider;
40 import org.efs.openreports.providers.ParameterProvider;
41 import org.efs.openreports.providers.PropertiesProvider;
42 import org.efs.openreports.providers.ProviderException;
43 import org.efs.openreports.providers.ReportLogProvider;
44 import org.efs.openreports.providers.ReportProvider;
45 import org.efs.openreports.providers.SchedulerProvider;
46 import org.efs.openreports.providers.UserProvider;
47 import org.efs.openreports.services.info.ReportInfo;
48 import org.efs.openreports.services.input.ReportServiceInput;
49 import org.efs.openreports.services.input.ServletReportServiceInput;
50 import org.efs.openreports.services.util.Converter;
51 import org.efs.openreports.util.LocalStrings;
52
53 /**
54  * ReportService implementation using standard OpenReports providers.
55  *
56  * @author Erik Swenson
57  */

58
59 public class ReportServiceImpl implements ReportService
60 {
61     private static Logger log = Logger.getLogger(ReportServiceImpl.class.getName());
62
63     private ReportProvider reportProvider;
64     private ReportLogProvider reportLogProvider;
65     private SchedulerProvider schedulerProvider;
66     private UserProvider userProvider;
67     private DirectoryProvider directoryProvider;
68     private ParameterProvider parameterProvider;
69     private DataSourceProvider dataSourceProvider;
70     private PropertiesProvider propertiesProvider;
71
72     public ReportServiceImpl()
73     {
74         log.info("ReportService: Started");
75     }
76     
77     /**
78      * Generate a Report and return a ReportEngineOutput. Contents of the
79      * ReportEngineOutput vary with the deliveryMethod and exportType of the
80      * ReportServiceInput.
81      *
82      * Returns errors messages in the message field of the ReportServiceOutput.
83      *
84      * Includes Report Logging functionality.
85      */

86     public ReportEngineOutput generateReport(ReportServiceInput reportInput)
87     {
88         ReportEngineOutput reportOutput = new ReportEngineOutput();
89         
90         if (reportInput.getUserName() == null || reportInput.getReportName() == null)
91         {
92             reportOutput.setContentMessage("Invalid ReportInput - UserName and ReportName required.");
93             log.warn("generateReport: " + reportOutput.getContentMessage());
94             
95             return reportOutput;
96         }
97         
98         ReportLog reportLog = null;
99         
100         try
101         {
102             Report report = reportProvider.getReport(reportInput.getReportName());
103             if (report == null)
104             {
105                 reportOutput.setContentMessage("Invalid ReportInput - Report not found: " + reportInput.getReportName());
106                 log.warn("generateReport: " + reportOutput.getContentMessage());
107                 
108                 return reportOutput;
109             }
110             
111             ReportUser user = userProvider.getUser(reportInput.getUserName());
112             if (user == null)
113             {
114                 reportOutput.setContentMessage("Invalid ReportInput - User not found: " + reportInput.getUserName());
115                 log.warn("generateReport: " + reportOutput.getContentMessage());
116                 
117                 return reportOutput;
118             }
119             
120             if (!user.isValidReport(report))
121             {
122                 reportOutput.setContentMessage("Invalid ReportInput - "
123                         + reportInput.getUserName() + " not authorized to run: "
124                         + reportInput.getReportName());
125                 
126                 log.warn("generateReport: " + reportOutput.getContentMessage());
127                 
128                 return reportOutput;
129             }
130             
131             reportLog = new ReportLog(user, report, new Date JavaDoc());
132             reportLog = reportLogProvider.insertReportLog(reportLog);
133             
134             log.info("generateReport: " + user.getName() + " : " + report.getName() + " : " + reportInput.getDeliveryMethod());
135             
136             if (reportInput.getDeliveryMethod().equals(ReportService.DELIVERY_EMAIL))
137             {
138                 ReportSchedule schedule = new ReportSchedule();
139                 schedule.setReport(report);
140                 schedule.setUser(user);
141                 schedule.setReportParameters(buildParameterMap(reportInput, report));
142                 schedule.setExportType(reportInput.getExportType());
143                 schedule.setRecipients(user.getEmail());
144                 schedule.setScheduleName(report.getId() + "|" + new Date JavaDoc().getTime());
145                 schedule.setScheduleDescription(reportInput.getScheduleDescription());
146                 schedule.setScheduleType(ReportSchedule.ONCE);
147                 
148                 // advanced scheduling
149
if (reportInput.getStartDate() != null)
150                 {
151                     if (!user.isAdvancedScheduler())
152                     {
153                         throw new ProviderException("Not Authorized: Advanced Scheduling permission required");
154                     }
155                     
156                     schedule.setScheduleType(reportInput.getScheduleType());
157                     schedule.setStartDate(reportInput.getStartDate());
158                     schedule.setStartHour(reportInput.getStartHour());
159                     schedule.setStartMinute(reportInput.getStartMinute());
160                     schedule.setStartAmPm(reportInput.getStartAmPm());
161                     schedule.setHours(reportInput.getHours());
162                     schedule.setCronExpression(reportInput.getCronExpression());
163                 }
164                                 
165                 schedulerProvider.scheduleReport(schedule);
166             }
167             else
168             {
169                 ReportEngine reportEngine = new ReportEngine(dataSourceProvider, directoryProvider, propertiesProvider);
170                 
171                 ReportEngineInput engineInput = new ReportEngineInput(report, buildParameterMap(reportInput, report));
172                 engineInput.setExportType(reportInput.getExportType());
173                 
174                 reportOutput = reportEngine.generateReport(engineInput);
175             }
176             
177             reportOutput.setContentMessage(LocalStrings.getString(LocalStrings.SERVICE_REQUEST_COMPLETE));
178             
179             reportLog.setStatus(ReportLog.STATUS_SUCCESS);
180             reportLog.setEndTime(new Date JavaDoc());
181             reportLogProvider.updateReportLog(reportLog);
182         }
183         catch (Exception JavaDoc e)
184         {
185             log.error(e);
186             reportOutput.setContentMessage(e.getMessage());
187             
188             if (reportLog != null && reportLog.getId() != null)
189             {
190                 reportLog.setStatus(ReportLog.STATUS_FAILURE);
191                 reportLog.setMessage(e.getMessage());
192                 reportLog.setEndTime(new Date JavaDoc());
193                 
194                 try
195                 {
196                     reportLogProvider.updateReportLog(reportLog);
197                 }
198                 catch (Exception JavaDoc ex)
199                 {
200                     log.error("Unable to update ReportLog: " + ex.getMessage());
201                 }
202             }
203         }
204         
205         log.info("generateReport: " + reportOutput.getContentMessage());
206         
207         return reportOutput;
208     }
209     
210     public ReportInfo getReportInfo(String JavaDoc reportName)
211     {
212         ReportInfo reportInfo = null;
213         
214         try
215         {
216             Report report = reportProvider.getReport(reportName);
217             if (report != null)
218             {
219                 reportInfo = Converter.convertToReportInfo(report);
220             }
221         }
222         catch(ProviderException pe)
223         {
224             log.warn(pe);
225         }
226         
227         return reportInfo;
228     }
229
230     /**
231      * Builds report parameter map from incoming ReportServiceInput and adds
232      * standard report parameters.
233      */

234     private Map JavaDoc buildParameterMap(ReportServiceInput reportServiceInput, Report report) throws ProviderException
235     {
236         Map JavaDoc inputParameters = new HashMap JavaDoc();
237         
238         if (reportServiceInput instanceof ServletReportServiceInput)
239         {
240             inputParameters = ((ServletReportServiceInput) reportServiceInput).getParameterMap();
241         }
242         else
243         {
244             String JavaDoc[] parameters = reportServiceInput.getParameters();
245
246             if (parameters != null)
247             {
248                 /*
249                  * Incoming String[] containing Strings in the format 'city=Boston'
250                  * is converted into a Map with a String key and a String[] value
251                  * in order to mimic the format of the map returned by
252                  * HttpServletRequest.getParameterMap() and required by
253                  * parameterProvider.getReportParametersMap(...)
254                  */

255                 for (int i = 0; i < parameters.length; i++)
256                 {
257                     StringTokenizer JavaDoc tokenizer = new StringTokenizer JavaDoc(parameters[i], "=");
258                     if (tokenizer.countTokens() == 2)
259                     {
260                         String JavaDoc key = tokenizer.nextToken();
261                         String JavaDoc[] value = new String JavaDoc[] { tokenizer.nextToken() };
262
263                         if (inputParameters.containsKey(key))
264                         {
265                             String JavaDoc[] currentValue = (String JavaDoc[]) inputParameters.get(key);
266                             value = (String JavaDoc[]) ArrayUtils.addAll(currentValue, value);
267                         }
268
269                         inputParameters.put(key, value);
270                     }
271                     else
272                     {
273                         log.warn("Invalid Parameter Format: " + parameters[i]);
274                     }
275                 }
276             }
277         }
278         
279         Map JavaDoc parsedParameters = parameterProvider.getReportParametersMap(report.getParameters(), inputParameters);
280         parsedParameters.put(ORStatics.IMAGE_DIR, new File JavaDoc(directoryProvider.getReportImageDirectory()));
281         parsedParameters.put(ORStatics.REPORT_DIR, new File JavaDoc(directoryProvider.getReportDirectory()));
282         
283         return parsedParameters;
284     }
285
286     public void setDirectoryProvider(DirectoryProvider directoryProvider)
287     {
288         this.directoryProvider = directoryProvider;
289     }
290
291     public void setParameterProvider(ParameterProvider parameterProvider)
292     {
293         this.parameterProvider = parameterProvider;
294     }
295
296     public void setReportLogProvider(ReportLogProvider reportLogProvider)
297     {
298         this.reportLogProvider = reportLogProvider;
299     }
300
301     public void setReportProvider(ReportProvider reportProvider)
302     {
303         this.reportProvider = reportProvider;
304     }
305
306     public void setSchedulerProvider(SchedulerProvider schedulerProvider)
307     {
308         this.schedulerProvider = schedulerProvider;
309     }
310
311     public void setUserProvider(UserProvider userProvider)
312     {
313         this.userProvider = userProvider;
314     }
315
316     public void setDataSourceProvider(DataSourceProvider dataSourceProvider)
317     {
318         this.dataSourceProvider = dataSourceProvider;
319     }
320
321     public void setPropertiesProvider(PropertiesProvider propertiesProvider)
322     {
323         this.propertiesProvider = propertiesProvider;
324     }
325 }
326
Popular Tags