ReportSource


1   package com.calipso.reportgenerator.reportmanager;
2   
3   import com.calipso.reportgenerator.reportdefinitions.types.DataSourceDefinitionSourceTypeType;
4   import com.calipso.reportgenerator.reportcalculator.*;
5   import com.calipso.reportgenerator.common.*;
6   import com.calipso.reportgenerator.services.DataSourceDefinitionConnectionString;
7   import com.calipso.common.DateEx;
8   
9   import java.util.*;
10  import java.text.DateFormat  ;
11  import java.text.SimpleDateFormat  ;
12  import java.io.Serializable  ;
13  
14  import com.calipso.reportgenerator.reportcalculator.IDataSource;
15  import com.calipso.reportgenerator.common.InfoException;
16  
17  /**
18   * Esta clase se crea a partir de un ReportSourceDefinition y es la
19   * responsable de aplicar los filtros necesarios a partir de un
20   * ReportDataSource, tambi�n tiene la responsabilidad de componer la
21   * query, cargar el Pivot y ejecutar el c�lculo.
22   */
23  
24  public class ReportSource implements Serializable  {
25  
26    private Matrix matrix;
27    private List filterDefinitions;
28    private Date lastExecution;
29    private Map paramValues;
30    private ReportGeneratorConfiguration reportGeneratorConfiguration;
31    private ReportSpec reportSpec;
32  
33  
34    /**
35     * Inicializa una instancia a partir de su definici�n (ReportSpec)
36  
37     * @param reportSpec
38     * @param reportGeneratorConfiguration
39     * @param init
40     * @throws InfoException
41     */
42  
43    private ReportSource(ReportSpec reportSpec, ReportGeneratorConfiguration reportGeneratorConfiguration, boolean init) throws InfoException {
44      if ((reportSpec == null) || (reportGeneratorConfiguration == null)) {
45        throw new InfoException(LanguageTraslator.traslate("42"));
46      }
47      else {
48        this.reportSpec = reportSpec;
49        this.reportGeneratorConfiguration = reportGeneratorConfiguration;
50        this.lastExecution = null;
51        this.paramValues = null;
52        if (init){
53          initializeContents();
54        }
55      }
56    }
57  
58    /**
59     * Inicializa una instancia a partir de un ReportSpec
60     * @param reportSpec
61     * @param reportGeneratorConfiguration
62     * @throws InfoException
63     */
64  
65    public ReportSource(ReportSpec reportSpec, ReportGeneratorConfiguration reportGeneratorConfiguration) throws InfoException {
66      this(reportSpec, reportGeneratorConfiguration, true);
67    }
68  
69  
70    /**
71     * Inicializa una instancia a partir de un ReportSpec, y la matriz con la
72     * informaci�n, en caso que haya sido pre-procesada.
73     * @param reportSpec
74     * @param matrix
75     * @param reportGeneratorConfiguration
76     * @throws InfoException
77     */
78    public ReportSource(ReportSpec reportSpec, Matrix matrix, ReportGeneratorConfiguration reportGeneratorConfiguration) throws InfoException {
79      this(reportSpec, reportGeneratorConfiguration, false);
80      if (matrix == null) {
81        throw new InfoException(LanguageTraslator.traslate("43"));
82      }
83      else {
84        this.matrix = matrix;
85        initializeContents();
86      }
87    }
88  
89    /**
90     * Inicializa una instancia a partir de un ReportSpec, y los valores de los pre-filtros, este constructor
91     * solo debe utilizarse para reportes no cacheados
92     * @param reportSpec
93     * @param paramValues
94     * @param reportGeneratorConfiguration
95     * @throws InfoException
96     */
97    public ReportSource(ReportSpec reportSpec, Map paramValues, ReportGeneratorConfiguration reportGeneratorConfiguration) throws InfoException {
98      this(reportSpec, reportGeneratorConfiguration, false);
99      this.paramValues = paramValues;
100     initializeContents();
101   }
102 
103   /**
104    * Inicializa una instancia a partir de un ReposrSourceDefinition, y la matriz con la
105    * informaci�n, en caso que haya sido pre-procesada y la fecha de �ltima ejecuci�n.
106    * Este constructor se utiliza para reportes incrementales.
107    * @param reportSpec
108    * @param matrix
109    * @param lastExecution
110    * @param reportGeneratorConfiguration
111    * @throws InfoException
112    */
113   public ReportSource(ReportSpec reportSpec, Matrix matrix, Date lastExecution, ReportGeneratorConfiguration reportGeneratorConfiguration) throws InfoException {
114     this(reportSpec, reportGeneratorConfiguration, false);
115     this.matrix = matrix;
116     this.lastExecution = lastExecution;
117     initializeContents();
118   }
119 
120 
121   /**
122    * Inicializa los contenidos
123    * En los cubos no cacheados, ejecuta todos los DataSources
124    * En el caso de los cacheados, ejecutalos DataSources solo cuando el reporte no fue pre-procesado o cuando ya no est�
125    * vigente.
126    * En el caso de los incrementales, siempre ejecuta los DataSource con un filtro compuesto a partir del valor de
127    * <code>lastExecution</code>
128    * @throws InfoException Si se produce un error al llenar la matriz
129    */
130   private void initializeContents() throws InfoException {
131     fillFromSources(matrix);
132   }
133 
134 
135   /**
136    * Devuelve la matriz de datos resultante de la ejecuci�n de los DataSources. Es una matriz de dos dimensiones que se
137    * utilizar� para obtener los distintos reportes.
138    * @return la matriz
139    */
140   public Matrix getMatrix() {
141     return matrix;
142   }
143 
144   /**
145    * Sirve para inicializar la matriz con valores pre-procesados
146    * @param matrix
147    */
148 
149   public void setMatrix(Matrix matrix) {
150     this.matrix = matrix;
151   }
152 
153   /**
154    * Devuelve un objeto capaz de resolver un origen de datos, en este m�todo se devuelve el objeto apropiado seg�n el
155    * tipo de origen de datos (XML, OQL, etc).
156    * @param dataSourceSpec
157    * @return
158    * @throws InfoException
159    */
160   private ReportDataSource newReportDataSourceFrom(ReportDataSourceSpec dataSourceSpec) throws InfoException {
161     try {
162       ReportDataSource reportDataSource;
163       switch (dataSourceSpec.getSourceType().getType()) {
164         case DataSourceDefinitionSourceTypeType.XML_TYPE:
165           ReportManagerLogger.debug(LanguageTraslator.traslate("204"));
166           reportDataSource = new XmlReportDataSource(getReportSpec(), dataSourceSpec, getReportGeneratorConfiguration());
167           break;
168         case DataSourceDefinitionSourceTypeType.SQL_TYPE:
169           ReportManagerLogger.debug(LanguageTraslator.traslate("202"));
170           reportDataSource = new SQLReportDataSource(getReportSpec(), dataSourceSpec, getReportGeneratorConfiguration(), new DataSourceDefinitionConnectionString(dataSourceSpec.getExternalConnectionValues()));
171           break;
172 /*        case DataSourceDefinitionSourceTypeType.CALC_TYPE:        //todo revisar la implementacion
173           ReportManagerLogger.debug(LanguageTraslator.traslate("203"));
174           reportDataSource = new OOCalcReportDataSource(getReportSpec(), dataSourceSpec, getReportGeneratorConfiguration());
175           break;*/
176         case DataSourceDefinitionSourceTypeType.EXCEL_TYPE:
177           ReportManagerLogger.debug(LanguageTraslator.traslate("317"));
178           reportDataSource = new ExcelReportDataSource(getReportSpec(), dataSourceSpec, getReportGeneratorConfiguration());
179           break;
180         default:
181           reportDataSource = null;
182       }
183       if (reportDataSource != null) {
184         reportDataSource.setFilter(getCubeFilter(reportDataSource.getFilterVarMode(), dataSourceSpec));
185       }
186       return reportDataSource;
187     } catch (Exception   e) {
188       throw new InfoException(LanguageTraslator.traslate("44"), e);
189     }
190   }
191 
192 
193   /**
194    * Ejecuta todos los or�genes de datos para llenar la lista de registros (<code>rows</code>)de la Matriz.
195    * @param matrix
196    * @throws InfoException
197    */
198   private void fillFromSources(Matrix matrix) throws InfoException {
199     ReportManagerLogger.debug(LanguageTraslator.traslate("201"));
200     if(matrix==null){
201       matrix = DataSourceBuilder.buildMatrix(getReportGeneratorConfiguration(), getReportSpec());
202     }
203     boolean incremental = !getReportSpec().getIncrementalDimension().equals("");
204     boolean cached = getReportSpec().getCached() || getReportSpec().getDatawarehouseSaved();
205     boolean empty = /*matrix==null ||*/ matrix.isEmpty();
206     if (incremental || !cached || empty) {
207       Iterator iterator = getReportSpec().getDataSourceSpecs().iterator();
208       while (iterator.hasNext()) {
209         if (/*matrix!=null &&*/ isFull(matrix.size())) return;
210         ReportDataSourceSpec dataSourceSpec = (ReportDataSourceSpec) iterator.next();
211         ReportDataSource reportDataSource = newReportDataSourceFrom(dataSourceSpec);
212         System.out.println("Comienzo carga" + new Date());
213         /*IDataSource dataSource = */reportDataSource.getDataSource(matrix);
214         System.out.println("Fin carga" + new Date());
215         /*Matrix sourceMatrix = getMatrix(dataSource);
216         if(sourceMatrix!=null){
217           //Si se puede obtener una matrix del data source se la utiliza
218           matrix = fillMatrix(matrix, sourceMatrix);
219         }else{                                                                                      
220           //Sino, se construye una matrix para llenar
221           if(matrix == null){
222             matrix = DataSourceBuilder.buildMatrix(getReportGeneratorConfiguration(), getReportSpec());
223           }
224           fillRows(dataSource, matrix, dataSourceSpec);
225         }*/
226       }
227     }
228     this.matrix = matrix;
229   }
230 
231   /*private Matrix getMatrix(IDataSource dataSource) {
232     if(dataSource instanceof Matrix){
233       return (Matrix)dataSource;
234     }
235     return null;
236   }
237 
238   private Matrix fillMatrix(Matrix matrix, Matrix sourceMatrix) throws InfoException{
239     if(matrix==null){
240       matrix = sourceMatrix;
241     }else{
242       matrix.addAll(sourceMatrix);
243     }
244     return matrix;
245   }*/
246 
247   /**
248    * Ejecuta un origen de datos y agrega las filas que da como resultado a la lista de filas de la Matriz.
249    * @param dataSource
250    * @param matrix
251    * @throws InfoException
252    */
253   private void fillRows(IDataSource dataSource, Matrix matrix, ReportDataSourceSpec dataSourceSpec) throws InfoException {
254     int rowSize = getDimensionsCount() + getMetricsCount();
255     try {
256       if (dataSource != null) {
257         for (int i = 0; i < dataSource.getRowCount(); i++) {
258           if (isFull(matrix.size())) return;
259           Object  [] row = new Object  [rowSize];
260           fillRow(row, dataSource, i, dataSourceSpec);
261           matrix.add(row);
262         }
263       }
264     } catch (Exception   e) {
265       throw new InfoException(LanguageTraslator.traslate("45"), e);
266     }
267   }
268 
269   /**
270    * Determina si se ha alcanzado el n�mero m�ximo de registros
271    * @param rowCount
272    * @return true si se alcanzo el n�mero m�ximo de registros
273    */
274 
275   private boolean isFull(int rowCount) {
276     return getMaxRowCount() > 0 ? getMaxRowCount() <= rowCount : false;
277   }
278 
279   /**
280    * Devuelve el n�mero m�ximo de l�neas a procesar, un valor menor o igual a 0 determina que un origen de reporte no
281    * tiene l�mite de registros.
282    * @return  n�mero m�ximo de l�neas a procesar
283    */
284   private int getMaxRowCount() {
285     return getReportSpec().getSourceMaxRowCount();
286   }
287 
288 
289   /**
290    * Devuelve una Dimensi�n a partir de su nombre
291    * @param name
292    * @return Dimensi�n
293    */
294   public ReportDimensionSpec getDimensionfromName(String   name) {
295     return getReportSpec().getDimensionFromName(name);
296   }
297 
298 
299   /**
300    * Devuelve una m�trica a partir de su nombre
301    * @param name
302    * @return m�trica
303    */
304   public ReportMetricSpec getMetricFromName(String   name) {
305     return getReportSpec().getMetricFromName(name);
306   }
307 
308   /**
309    * Llena un registro de la <code>Matrix</code> a partir de un registro del <code>DataSource</code>
310    * @param row registro de la <code>Matrix</code> a llenar
311    * @param dataSource objeto que contiene los registros obtenidos de un origen de datos (<code>ReportDataSource</code>)
312    * @param index �ndice del registro del <code>DataSource</code> con el que se llenar� el registro de la <code>Matrix</code>
313    * @param dataSourceSpec DataSourceSpec de donde se obtienen los datos
314    * @throws InfoException
315    */
316   private void fillRow(Object  [] row, IDataSource dataSource, int index, ReportDataSourceSpec dataSourceSpec) throws InfoException {
317     try {
318       List dimensions = getReportSpec().getDimensionsByIndex();
319       Iterator dimensionsIter = dimensions.iterator();
320       while (dimensionsIter.hasNext()) {
321         ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) dimensionsIter.next();
322         row[dimensionSpec.getReportSourceIndex()] = dimensionSpec.getValue(dataSource.getRowValues(index).toArray(), dataSourceSpec);
323       }
324 
325       List metrics = getReportSpec().getMetricsByIndex();
326       Iterator metricsIter = metrics.iterator();
327       while (metricsIter.hasNext()) {
328         ReportMetricSpec metricSpec = (ReportMetricSpec) metricsIter.next();
329         row[metricSpec.getReportSourceIndex()] = metricSpec.getValue(dataSource.getRowValues(index).toArray());
330       }
331     } catch (Exception   e) {
332       throw new InfoException(LanguageTraslator.traslate("46"), e);
333     }
334   }
335 
336   /**
337    * Devuelve la cantidad de Dimensiones
338    * @return cantidad de Dimensiones
339    */
340 
341   private int getDimensionsCount() {
342     return getReportSpec().getDimensionSpecs().size();
343   }
344 
345 
346   /**
347    * Devuelve la cantidad de M�tricas
348    * @return cantidad de M�tricas
349    */
350   private int getMetricsCount() {
351     return getReportSpec().getMetricSpecs().size();
352   }
353 
354   /**
355    * Crea los pre-filtros a partir de las <code>FilterDefinitions</code> del <code>ReportSourceDefinition</code>
356    * @param reportDataSourceSpec
357    * @return lista de pre-filtros
358    */
359   protected List getFilterDefinitions(ReportDataSourceSpec reportDataSourceSpec) {
360     if (filterDefinitions == null) {
361       filterDefinitions = new ArrayList();
362 
363       ReportFilter incFilter = getIncrementalFilter(reportDataSourceSpec);
364       if (incFilter != null) {
365         filterDefinitions.add(incFilter);
366       }
367       ReportFilter maxRowsFilter = getMaxRowsFilter();
368       if (maxRowsFilter != null) {
369         filterDefinitions.add(maxRowsFilter);
370       }
371       Collection filterSpecs = getReportSpec().getPreFilterSpecs();
372       for (Iterator iterator = filterSpecs.iterator(); iterator.hasNext();) {
373         ReportFilterSpec reportFilterSpec = (ReportFilterSpec) iterator.next();
374         ReportFilter reportFilter = new ReportFilter(reportFilterSpec);
375         filterDefinitions.add(reportFilter);
376       }
377     }
378     return filterDefinitions;
379   }
380 
381   public ReportSpec getReportSpec() {
382     return reportSpec;
383   }
384 
385   /**
386    * Crea un filtro del tipo "mayor que" tomando como par�metro la fecha de �ltima ejecuci�n y aplicado sobre
387    * la dimension <code>incrementalDimension</code>, este filtro es el que resuelve el c�lculo incremental de reportes
388    * @return filtro
389    */
390   private ReportFilter getIncrementalFilter(ReportDataSourceSpec reportDataSourceSpec) {
391     ReportFilter incFilter = null;
392     ReportFilterSpec incFilterSpec = getReportSpec().getIncrementalFilterSpec(getLastExecution());
393     if (incFilterSpec != null){
394       incFilter = new ReportFilter(incFilterSpec);
395       getParamValues().put("INCREMENTALVALUE", SharedDate.newFrom(new DateEx(getLastExecution())));//getDateString(getLastExecution(), reportDataSourceSpec));
396     }
397     return incFilter;
398   }
399 
400   private ReportFilter getMaxRowsFilter() {
401     ReportFilter maxRowsFilter = null;
402     ReportFilterSpec maxRowsFilterSpec = getReportSpec().getSourceMaxRowsFilterSpec();
403     if (maxRowsFilterSpec != null){
404       maxRowsFilter = new ReportFilter(maxRowsFilterSpec );
405     }
406     return maxRowsFilter;
407   }
408 
409   /**
410    * Devuelve los valores de los par�metros de pre-filtros
411    * @return valores de parametros para los pre-filtros
412    */
413   private Map getParamValues() {
414     if (paramValues == null) {
415       paramValues = new HashMap();
416     }
417     return paramValues;
418   }
419 
420 
421   /**
422    * Se utiliza para obtener el valor de la fecha para le filtro incremental
423    * @param date
424    * @return valor de fecha en prefiltro incremental
425    */
426   private String   getDateString(Date date, ReportDataSourceSpec reportDataSourceSpec) {
427     int dataType = getReportSpec().getDimensionFromName(getReportSpec().getIncrementalDimension()).getDataType().getType();
428     DateFormat   dateFormat = new SimpleDateFormat  (reportDataSourceSpec.getPattern(dataType));
429     return dateFormat.format(date);
430   }
431 
432   /* Formato de la fecha,
433    * Nota: este m�todo est� resuelto de manera provisoria, esta informaci�n ser� le�da de archivos de configuraci�n
434    *
435    * @return
436 
437   public String getDatePattern() {
438     return getReportSpec().getDatePattern();
439   }*/
440 
441 
442   /**
443    * Utiliza la informaci�n de los FilterDefinitions para construir un filtro que pueden utilizar los ReportDataSource
444    * @param mode
445    * @return ExpressionCubeFilter
446    */
447   protected ExpressionCubeFilter getCubeFilter(int mode, ReportDataSourceSpec dataSourceSpec) throws InfoException{
448     ExpressionCubeFilter cubeFilter;
449     Map currentParamValues = new HashMap();
450     List filterDefs = getFilterDefinitions(dataSourceSpec);
451     currentParamValues = ReportFilterBuilder.mergeParamValues(currentParamValues, getReportSpec().getParamValues(true));
452     currentParamValues = ReportFilterBuilder.mergeParamValues(currentParamValues, getParamValues());
453     ReportFilterBuilder filterBuilder = new ReportFilterBuilder(filterDefs, currentParamValues, mode);
454     cubeFilter = filterBuilder.getCubeFilter(getReportSpec(), dataSourceSpec);
455     return cubeFilter;
456   }
457 
458 
459   /**
460    * Devuelve la fecha de la �ltima ejecuci�n del reporte.
461    * @return fecha de la �ltima ejecuci�n del reporte
462    */
463   public Date getLastExecution() {
464     return lastExecution;
465   }
466 
467   /**
468    * Especifica la fecha del al �ltima ejecuci�n del reporte.
469    * @param lastExecution
470    */
471 
472   public void setLastExecution(Date lastExecution) {
473     this.lastExecution = lastExecution;
474   }
475 
476   /**
477    * Devuelve la configuraci�n del report generator
478    * @return configuraci�n del report generator
479    */
480   public ReportGeneratorConfiguration getReportGeneratorConfiguration() {
481     return reportGeneratorConfiguration;
482   }
483 }
484
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags