Java > Open Source Codes > com > calipso > reportgenerator > common > ReportQuery


1 package com.calipso.reportgenerator.common;
2
3 import com.calipso.reportgenerator.reportcalculator.*;
4 import com.calipso.reportgenerator.reportdefinitions.types.*;
5 import com.calipso.reportgenerator.reportdefinitions.*;
6 import com.calipso.reportgenerator.common.LanguageTraslator;
7 import com.calipso.common.DateEx;
8
9 import java.util.*;
10 import java.text.MessageFormat ;
11 import java.io.Serializable ;
12
13 /** Esta clase contiene la información necesaria para ejecutar una consulta a sobre los datos, especificando las,
14  * agrupaciones, filtros, campos visibles, ordenamiento, etc.
15  */
16 public class ReportQuery implements Serializable {
17   private ReportSpec reportSpec;
18   private List dimensions;
19   private List metrics;
20   private List accumulableMetrics;
21   private Map paramValues;
22   private List filterDefinitions;
23   private Map dimensionFilterValues;
24   private boolean visibleTotals;
25   private EnumerationCubeFilter rankingFilter;
26   private EnumerationCubeFilter excludeGroupFilter = null;
27
28   /** Inicializa una nueva Consulta, asignandole a las dimensiones y a las métrcias las propiedades por defecto que se
29    * obtienen de la definición de reporte
30    * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
31    * de las rows del DataSource.
32    * @throws com.calipso.reportgenerator.common.InfoException
33    */
34   public ReportQuery(ReportSpec reportSpec) throws InfoException {
35     this(reportSpec, true);
36   }
37
38   /**
39    * Inicializa una nueva Consulta permitiendo especificar si se desea que a las dimensiones y las métricas se les asignen
40    * las propiedades por defecto que se obtienen de la definición del reporte.
41    * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
42    * de las rows del DataSource.
43    * @param defaultInitialize true = valores de propiedades por defecto segun definición de reporte. false = ninguna métrica
44    * visible, ninguna dimension agrupa (Location = PAGE).
45    */
46   public ReportQuery(ReportSpec reportSpec, boolean defaultInitialize) throws InfoException {
47     this.reportSpec = reportSpec;
48     initialize(defaultInitialize);
49   }
50
51   /**
52    * Inicializa la query y le aplica los valores del Report view indicado
53    * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
54    * de las rows del DataSource.
55    * @param reportView Continen los valores especificos para la vista solicitada
56    */
57   public ReportQuery(ReportSpec reportSpec, ReportView reportView) throws InfoException {
58     this(reportSpec, true);
59     overrideQuery(reportView);
60   }
61
62   /**
63    * Sobreescribe los valores particulares de el report view
64    * @param reportView
65    */
66   private void overrideQuery(ReportView reportView) throws InfoException {
67     if (reportView != null) {
68       overrideParamValues(reportView);
69       overrideDimensionValues(reportView);
70       overrideMetricsValues(reportView);
71       overrideFiltersValues(reportView);
72       generalOverride(reportView);
73     }
74   }
75
76   private void overrideParamValues(ReportView reportView) throws InfoException {
77     if (reportView.getViewParameterValues()!=null){
78       Map overrideParams = getParamValuesFromView(reportView.getViewParameterValues(), getReportSpec());
79       this.paramValues = ReportFilterBuilder.mergeParamValues( getParamValues(), overrideParams);
80     }
81   }
82
83   public static Map getParamValuesFromView(ViewParameterValues viewParameters, ReportSpec reportSpec) throws InfoException {
84     Map result = new HashMap();
85     ViewParameterValue[] viewParameterValues = viewParameters.getViewParameterValue();
86     for (int i = 0; i < viewParameterValues.length; i++) {
87       //Aca!
88 //Hacer que estoy view parametros todos string se transformen en parametros con tipos shared
89 ViewParameterValue viewParameterValue = viewParameterValues[i];
90       ReportFilterSpec filterSpec = reportSpec.getFilterSpecFromParamName(viewParameterValue.getViewParamName());
91       int dataType;
92       if(filterSpec.getDataType()!=null){
93         dataType = filterSpec.getDataType().getType();
94       }else{
95         dataType = reportSpec.getDimensionFromName(filterSpec.getDimensionName()).getDataType().getType();
96       }
97       Object value = SharedData.newFrom(dataType, viewParameterValue.getViewParamValue());
98       result.put(viewParameterValue.getViewParamName(), value);
99     }
100     return result;
101   }
102
103   private void overrideFiltersValues(ReportView reportView) throws InfoException{
104     DimensionProperties pr = reportView.getDimensionProperties();
105     DimensionProperty [] properties = pr.getDimensionProperty();
106     for(int i = 0 ; i < properties.length ; i++) {
107       Set set = new TreeSet();
108       DimensionProperty property = properties [i];
109       ReportDimensionSpec dimensionSpec = reportSpec.getDimensionFromName(property.getDimensionName());
110       int dimensionIndex = dimensionSpec.getIndex();
111       //int dimensionIndex = reportSpec.getDimensionFromName(property.getDimensionName()).getIndex();
112 ExcludeValue [] values = property.getExcludeValue();
113       for(int j = 0 ; j < values.length ; j++) {
114         ExcludeValue value = values [j];
115         switch(dimensionSpec.getDataType().getType()){
116           case ReportDataType.STRING_TYPE:
117             set.add(value.getValue());
118             break;
119           case ReportDataType.DATETIME_TYPE:
120           case ReportDataType.DATE_TYPE:
121             try {
122               set.add(SharedDate.newFrom(new DateEx(value.getValue())));
123             }catch (InfoException e) {
124               throw new InfoException(LanguageTraslator.traslate("262") + value.getValue(),e);
125             }
126             break;
127           case ReportDataType.FLOAT_TYPE:
128             set.add(SharedFloat.newFrom(new Float (value.getValue())));
129             break;
130           case ReportDataType.INTEGER_TYPE:
131             set.add(SharedInteger.newFrom(new Integer (value.getValue())));
132             break;
133           case ReportDataType.BOOLEAN_TYPE:
134             set.add(Boolean.valueOf(value.getValue()));
135             break;
136         }
137       }
138       getDimensionFilterValues().put(new Integer (dimensionIndex), set);
139     }
140   }
141
142   /**
143    * Sobreescrie los parámetros generales de la query
144    * @param reportView
145    */
146   private void generalOverride(ReportView reportView) {
147     this.visibleTotals = reportView.getVisibleTotals();
148   }
149
150   /**
151    * Sobrescribe los valores la las metricas del reportview
152    * @param reportView
153    * @throws com.calipso.reportgenerator.common.InfoException
154    */
155   private void overrideMetricsValues(ReportView reportView) throws InfoException {
156     if (reportView.getMetricProperties() != null) {
157       int count = reportView.getMetricProperties().getMetricPropertyCount();
158       MetricProperty metricProperty;
159       for (int i = 0; i < count; i++) {
160         metricProperty = reportView.getMetricProperties().getMetricProperty()[i];
161         setMetricProperties(metricProperty.getMetricName(), metricProperty.getVisible(), i);
162       }
163     }
164   }
165
166   /**
167    * Asigna los valores
168    * @param reportView
169    * @throws com.calipso.reportgenerator.common.InfoException
170    */
171   private void overrideDimensionValues(ReportView reportView) throws InfoException {
172     int count = reportView.getDimensionProperties().getDimensionPropertyCount();
173     DimensionProperty dimensionProperty;
174     for (int i = 0; i < count; i++) {
175       dimensionProperty = reportView.getDimensionProperties().getDimensionProperty()[i];
176       setDimensionProperties(dimensionProperty.getDimensionName(), getLocationTypeFormView(dimensionProperty.getLocation()), getOrderTypeFormView(dimensionProperty.getOrder()), dimensionProperty.getUbication(), dimensionProperty.getRankMetricName());
177     }
178   }
179
180   /**
181    * Convierte los location de los properties del view al los del dimension definition
182    * @param locationType
183    * @return
184    */
185   private DimensionDefinitionLocationType getLocationTypeFormView(DimensionPropertyLocationType locationType) {
186     return DimensionDefinitionLocationType.valueOf(locationType.toString());
187   }
188
189   /**
190    * Convierte los order de los properties del view al los del dimension definition
191    * @param orderType
192    * @return
193    */
194   private DimensionDefinitionOrderType getOrderTypeFormView(DimensionPropertyOrderType orderType) {
195     return DimensionDefinitionOrderType.valueOf(orderType.toString());
196   }
197
198   /**
199    * Ejecuta la inicialización
200    * @param defaultInitialize
201    */
202   private void initialize(boolean defaultInitialize) {
203     this.dimensions = new ArrayList();
204     this.metrics = new ArrayList();
205     this.accumulableMetrics = new ArrayList();
206     this.visibleTotals = getReportSpec().isVisibleTotals();
207     DimensionDefinitionLocationType location;
208     Collection dimensions;
209
210     if ((getReportSpec().getReportType().getType() == ReportDefinitionReportTypeType.CUBE_TYPE) || (getReportSpec().getReportType().getType() == ReportDefinitionReportTypeType.CHARTCUBE_TYPE)) {
211       if (defaultInitialize) {
212         location = DimensionDefinitionLocationType.ROW;
213         dimensions = getReportSpec().getDimensionsByLocation(location);
214         addDimensionsByLocation(dimensions, location);
215         location = DimensionDefinitionLocationType.COLUMN;
216         dimensions = getReportSpec().getDimensionsByLocation(location);
217         addDimensionsByLocation(dimensions, location);
218         location = DimensionDefinitionLocationType.PAGE;
219         dimensions = getReportSpec().getDimensionsByLocation(location);
220         addDimensionsByLocation(dimensions, location);
221       }
222       else {
223         dimensions = getReportSpec().getDimensionSpecs().values();
224         addDimensionsByLocation(dimensions, DimensionDefinitionLocationType.PAGE);
225       }
226     }
227     else {
228       dimensions = getReportSpec().getDimensionsByGrouping(true);
229       addDimensionsByGrouping(dimensions, true);
230       dimensions = getReportSpec().getDimensionsByGrouping(false);
231       addDimensionsByGrouping(dimensions, false);
232     }
233
234
235     Collection metrics = getReportSpec().getMetricsByIndex();
236     for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
237       ReportMetricSpec metricSpec = (ReportMetricSpec) iterator.next();
238       int index = metricSpec.getReportSourceIndex();
239       boolean visible;
240       if (defaultInitialize) {
241         visible = metricSpec.getVisible();
242       }
243       else {
244         visible = false;
245       }
246       getMetrics().add(new QueryMetric(metricSpec.getName(), index, visible, getMetrics().size(), metricSpec.getAccumulable()));
247     }
248
249     Collection accmetrics = getReportSpec().getAccumulableMetricsByIndex();
250     for (Iterator iterator = accmetrics.iterator(); iterator.hasNext();) {
251       ReportMetricSpec metricSpec = (ReportMetricSpec) iterator.next();
252       int index = metricSpec.getReportSourceIndex();
253       boolean visible;
254       if (defaultInitialize) {
255         visible = metricSpec.getVisible();
256       }
257       else {
258         visible = false;
259       }
260       getAccumulableMetrics().add(new QueryMetric(metricSpec.getName(), index, visible, getMetrics().size(), metricSpec.getAccumulable()));
261     }
262   }
263
264   /**
265    * Inicializa los QueryDimension que representan a los ReportDimensionSpec que se reciben como parámetro, segun la
266    * ubicación de agrupación (para reportes tipo cubo)
267    * @param dimensions
268    * @param location
269    */
270
271   private void addDimensionsByLocation(Collection dimensions, DimensionDefinitionLocationType location) {
272     Iterator iter = dimensions.iterator();
273     int locationOrder = 0;
274     while (iter.hasNext()) {
275       ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter.next();
276       if (dimensionSpec.getInReportDefinition()) {
277         getDimensions().add(new QueryDimension(dimensionSpec.getName(), dimensionSpec.getReportSourceIndex(), location, dimensionSpec.getOrder(), locationOrder, false, dimensionSpec.getRankMetricName()));
278         locationOrder++;
279       }
280     }
281   }
282
283   /**
284    * Inicializa los QueryDimension que representan a los ReportDimensionSpec que se reciben como parámetro, segun la
285    * rol de agrupación (para reportes estáticos)
286    * @param dimensions
287    * @param groups
288    */
289   private void addDimensionsByGrouping(Collection dimensions, boolean groups) {
290     Iterator iter = dimensions.iterator();
291     int locationOrder = 0;
292     while (iter.hasNext()) {
293       ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter.next();
294       if (dimensionSpec.getInReportDefinition()) {
295         getDimensions().add(new QueryDimension(dimensionSpec.getName(), dimensionSpec.getReportSourceIndex(), DimensionDefinitionLocationType.PAGE, dimensionSpec.getOrder(), locationOrder, groups, dimensionSpec.getRankMetricName()));
296         locationOrder++;
297       }
298     }
299   }
300
301   /**
302    * Devuelve la query traducida a la forma que utiliza el módulo de cálculo de cubos.
303    * @return
304    * @throws com.calipso.reportgenerator.common.InfoException
305    */
306   public CubeQuery getCubeQuery() throws InfoException {
307     try {
308       CubeQuery query = new CubeQuery();
309       int[] rows = getCubeRowFields();
310       int[] cols = getCubeColumnFields();
311       int[] pages = getCubePageFields();
312       int[] metrics = getCubeMetricFields();
313       boolean[] ascending = getDimensionOrder();
314       int[] dimensioRank = getDimensionRank();
315       query.setRows(rows);
316       query.setColumns(cols);
317       query.setPages(pages);
318       query.setMetrics(metrics);
319       query.setAscending(ascending);
320       query.setDimensionRank(dimensioRank);
321       query.setFilter(getCubeFilter(getParamValues()));
322       query.setRankingFilter(getRankingFilter());
323       query.setEnumFilter(getEnumFilter());
324       query.setExcludeGroupFilter(excludeGroupFilter);
325       return query;
326     } catch (Exception e) {
327       throw new InfoException(LanguageTraslator.traslate("82"), e);
328     }
329   }
330
331
332   /** Devuelve una lista que contiene las métricas visibles
333    * @return
334    */
335   public List getVisibleMetrics() {
336     List list = new ArrayList();
337     for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
338       QueryMetric queryMetric = (QueryMetric) iterator.next();
339       if (queryMetric.getVisible()) {
340         list.add(queryMetric);
341       }
342     }
343     return list;
344   }
345
346   /** Devuelve una lista que contiene las métricas acumulables visibles
347    * @return
348    */
349   public List getVisibleAccumulableMetrics() {
350     List list = new ArrayList();
351     for (Iterator iterator = accumulableMetrics.iterator(); iterator.hasNext();) {
352       QueryMetric queryMetric = (QueryMetric) iterator.next();
353       if (queryMetric.getVisible()) {
354         list.add(queryMetric);
355       }
356     }
357     return list;
358   }
359
360
361   /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
362    * @return
363    */
364   private int[] getCubeMetricFields() {
365     List list = getMetrics();
366     int[] array = new int[list.size()];
367     int index = 0;
368     for (Iterator iterator = list.iterator(); iterator.hasNext();) {
369       QueryMetric queryMetric = (QueryMetric) iterator.next();
370       array[index] = queryMetric.getIndex();
371       index++;
372     }
373     return array;
374   }
375
376   /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
377    * acumulables
378    * @return
379    */
380
381   private int[] getStaticAccumulableMetricFields() {
382     List list = getAccumulableMetrics();
383     int[] array = new int[list.size()];
384     int index = 0;
385     for (Iterator iterator = list.iterator(); iterator.hasNext();) {
386       QueryMetric queryMetric = (QueryMetric) iterator.next();
387       array[index] = queryMetric.getIndex();
388       index++;
389     }
390     return array;
391   }
392
393   /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
394    * visibles
395    * @return
396    */
397
398   public int[] getCubeVisibleMetricFields() {
399     List list = getVisibleMetrics();
400     int[] array = new int[list.size()];
401     int index = 0;
402     for (Iterator iterator = list.iterator(); iterator.hasNext();) {
403       QueryMetric queryMetric = (QueryMetric) iterator.next();
404       array[index] = queryMetric.getIndex();
405       index++;
406     }
407     return array;
408   }
409
410
411   /** Devuelve un array de boolean que contiene el tipo de ordenamiento para cada dimension
412    * true = Ascendente
413    * false = Descendente
414    *
415    * @return
416    */
417   private boolean[] getDimensionOrder() {
418     int size = getReportSpec().getDimensionSpecs().size();
419     boolean[] orders = new boolean[size];
420     for (int i = 0; i < getDimensions().size(); i++) {
421       QueryDimension queryDimension = (QueryDimension) getDimensions().get(i);
422       orders[queryDimension.getIndex()] = queryDimension.getOrder().getType() == (DimensionDefinitionOrderType.A.getType());
423     }
424     return orders;
425   }
426
427
428   /**
429    * Devuelve un array que contiene los indices de las métricas que se utilizaran para ranking (ordenamiento por valor
430    * de métrica) para cada dimensión. Si no se utiliza ranking el valor es -1, ordenando por valor de dimensión.
431    */
432   private int[] getDimensionRank() {
433     int size = getReportSpec().getDimensionSpecs().size();
434     int[] dimensionRank = new int[size];
435     for (int i = 0; i < getDimensions().size(); i++) {
436       QueryDimension queryDimension = (QueryDimension) getDimensions().get(i);
437       ReportMetricSpec metricSpec = null;
438       if(queryDimension.getRankMetricName() != null){
439         metricSpec = getReportSpec().getMetricFromName(queryDimension.getRankMetricName());
440       }
441       int metricIndex;
442       if (metricSpec == null) {
443         metricIndex = -1;
444       }
445       else {
446         metricIndex = metricSpec.getReportSourceIndex();
447       }
448       dimensionRank[queryDimension.getIndex()] = metricIndex;
449     }
450     return dimensionRank;
451   }
452
453   /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las dimensiones
454    * segun las lista de dimensiones que recibe como parámetro
455    * Se utliza para resolver <code>getCubeRowFields()</code> y <code>getCubeColumnFields()</code>
456    * @param dimensions
457    * @return
458    */
459   private int[] getDimensionIndexArray(List dimensions) {
460     int size = dimensions.size();
461     int[] array = new int[size];
462     for (int i = 0; i < size; i++) {
463       QueryDimension queryDimension = (QueryDimension) dimensions.get(i);
464       array[i] = queryDimension.getIndex();
465     }
466     return array;
467   }
468
469   /** Devuleve los indices de las dimensions que agrupan por fila
470    *
471    * @return
472    */
473   private int[] getCubeRowFields() {
474     return getDimensionIndexArray(getRowDimensions());
475   }
476
477
478   /** Devuelve los indices de las dimensiones que agrupan por columna
479    *
480    * @return
481    */
482   private int[] getCubeColumnFields() {
483     return getDimensionIndexArray(getColumnDimensions());
484   }
485
486   /** Devuelve los indices de las dimensiones que agrupan por página
487    *
488    * @return
489    */
490
491   private int[] getCubePageFields() {
492     return getDimensionIndexArray(getPageDimensions());
493   }
494
495   /**
496    * Lista que contiene todas las dimensiones involucradas en la query
497    * @return
498    */
499
500   public List getDimensions() {
501     return dimensions;
502   }
503
504   /** Devuelve una lista con todas las dimensiones que agrupan según el parámetro <code>location</code>.
505    *
506    * @param location ubicación de las dimensiones que se desea obtener.
507    * @return
508    */
509   public List getDimensionsByLocation(DimensionDefinitionLocationType location) {
510
511     List list = new ArrayList();
512
513     for (Iterator iterator = getDimensions().iterator(); iterator.hasNext();) {
514       QueryDimension queryDimension = (QueryDimension) iterator.next();
515       if (queryDimension.getLocation().getType() == location.getType()) {
516         (list).add(queryDimension);
517       }
518     }
519     Collections.sort(list, new Comparator() {
520       public int compare(Object o1, Object o2) {
521         QueryDimension dim1 = (QueryDimension) o1;
522         QueryDimension dim2 = (QueryDimension) o2;
523         return dim1.getLocationOrder() - dim2.getLocationOrder();
524       }
525     });
526     return list;
527   }
528
529   /**
530    * Lista que contiene todas las dimensiones que agrupan por fila
531    * @return
532    */
533   public List getRowDimensions() {
534     return getDimensionsByLocation(DimensionDefinitionLocationType.ROW);
535   }
536
537   /**
538    * Lista que contiene todas las dimensiones que agrupan por columna
539    * @return
540    */
541   public List getColumnDimensions() {
542     return getDimensionsByLocation(DimensionDefinitionLocationType.COLUMN);
543   }
544
545   /**
546    * Lista que contiene todas las dimensiones que estan disponibles para agrupar
547    * @return
548    */
549   public List getPageDimensions() {
550     return getDimensionsByLocation(DimensionDefinitionLocationType.PAGE);
551   }
552
553   /**
554    * Lista que contiene todos las métricas que el usuario puede activar (ver)
555    * @return
556    */
557   public List getMetrics() {
558     return metrics;
559   }
560
561   /**
562    * Lista que contiene todos las métricas acumulables que el usuario puede activar (ver)
563    * @return
564    */
565   public List getAccumulableMetrics() {
566     return accumulableMetrics;
567   }
568
569
570   /**
571    * Devuelve la estructura <code>ReportSpec</code> que sirve para obtener los indices de las dimensiones y las métricas en
572    * la matriz que se llenó a partir de <code>DataSource</code>
573    * @return
574    */
575
576   public ReportSpec getReportSpec() {
577     return reportSpec;
578   }
579
580   /**
581    * Hace que todas las dimensiones no intervengan en la agrupación (ni por ROW ni por COLUMN)
582    * Inicializa los criterios de ordenamiento de los valores de dimensión en A (ascendente)
583    * Asigna -1 al orden relativo de las dimensiones
584    * Este método se utiliza para configurar una nueva query a partir de una query existente, la query
585    * que se obtiene por defecto está inicializada con los valores prefijados en el ReportSourceDefinition
586    */
587   public void clearQuery() {
588     for (int i = 0; i < getDimensions().size(); i++) {
589       QueryDimension queryDimension = (QueryDimension) getDimensions().get(i);
590       queryDimension.setProperties(DimensionDefinitionLocationType.PAGE, DimensionDefinitionOrderType.A, 1, "");
591     }
592     for (int i = 0; i < getMetrics().size(); i++) {
593       QueryMetric queryMetric = (QueryMetric) getMetrics().get(i);
594       queryMetric.setVisible(false);
595     }
596     paramValues = null;
597     dimensionFilterValues = null;
598   }
599
600   /**
601    * Especifica la ubicación de agrupación de una dimensión
602    * @param name
603    * @param location
604    * @throws com.calipso.reportgenerator.common.InfoException
605    */
606
607   public void setDimensionLocation(String name, DimensionDefinitionLocationType location) throws InfoException {
608     QueryDimension queryDimension = getQueryDimensionFromName(name);
609     queryDimension.setLocation(location);
610   }
611
612   /**
613    * Especifica el criterio de ordenamiento de los valores de una dimensión
614    * @param name
615    * @param order
616    * @throws com.calipso.reportgenerator.common.InfoException
617    */
618   public void setDimensionOrder(String name, DimensionDefinitionOrderType order) throws InfoException {
619     QueryDimension queryDimension = getQueryDimensionFromName(name);
620     queryDimension.setOrder(order);
621   }
622
623
624   /**
625    * Especifica el posición de la dimensión relativa a la localización
626    * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
627    * @param name
628    * @param order
629    * @throws com.calipso.reportgenerator.common.InfoException
630    */
631   public void setDimensionLocationOrder(String name, int order) throws InfoException {
632     QueryDimension queryDimension = getQueryDimensionFromName(name);
633     queryDimension.setLocationOrder(order);
634
635   }
636
637   /**
638    * Especifica el posición de la dimensión relativa a la localización, si el parámetro updateOrders es True, se reacomodan
639    * los ordenes desde la dimensión especificada en adelante
640    * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
641    * @param name
642    * @param order
643    * @throws com.calipso.reportgenerator.common.InfoException
644    */
645   public void setDimensionLocationOrder(String name, int order, boolean updateOrders) throws InfoException {
646     setDimensionLocationOrder(name, order);
647     if (updateOrders) {
648       locationOrderUpdated(name, order);
649     }
650   }
651
652   /**
653    * Reacomoda el orden de las dimensiones cuando cambia el orden
654    * @param name
655    * @param locationOrder
656    */
657   private void locationOrderUpdated(String name, int locationOrder) throws InfoException {
658     QueryDimension dimension = getQueryDimensionFromName(name);
659     List list = getDimensionsByLocation(dimension.getLocation());
660     for (Iterator iterator = list.iterator(); iterator.hasNext();) {
661       QueryDimension queryDimension = (QueryDimension) iterator.next();
662       if (name != queryDimension.getName() && queryDimension.getLocationOrder() >= locationOrder) {
663         queryDimension.setLocationOrder(queryDimension.getLocationOrder() + 1);
664       }
665     }
666   }
667
668   /**
669    * Especifica todas las propiedades de la dimension que afectan la query
670    *
671    * @param name
672    * @param location ubicación de agrupación (pueder ser null, en ese caso conserva el valor anterior)
673    * @param order criterio de ordenamiento (pueder ser null, en ese caso conserva el valor anterior)
674    * @param locationOrder posición relativa a la localización (para conservar la posición anterior se debe pasar valor -1)
675    * @param rankMetricName
676    * @throws com.calipso.reportgenerator.common.InfoException
677    */
678   public void setDimensionProperties(String name, DimensionDefinitionLocationType location, DimensionDefinitionOrderType order, int locationOrder, String rankMetricName) throws InfoException {
679     QueryDimension queryDimension = getQueryDimensionFromName(name);
680     queryDimension.setProperties(location, order, locationOrder, rankMetricName);
681     if (locationOrder >= 0) {
682       // locationOrderUpdated(name, locationOrder);
683 }
684   }
685
686   /**
687    * Especifica el nombre de la métrica por la que se desea ejecutar el ranking
688    * @param name
689    * @param rankMetricName
690    * @throws com.calipso.reportgenerator.common.InfoException
691    */
692   public void setDimensionRankMetricName(String name, String rankMetricName) throws InfoException {
693     QueryDimension queryDimension = getQueryDimensionFromName(name);
694     queryDimension.setRankMetricName(rankMetricName);
695   }
696
697   /**
698    * Especifica si se desea que los valores de la métrica estén visibles en el resultado de la query
699    * @param name
700    * @param visible
701    * @throws com.calipso.reportgenerator.common.InfoException
702    */
703   public void setMetricVisible(String name, boolean visible) throws InfoException {
704     QueryMetric queryMetric = getQueryMetricFromName(name);
705     queryMetric.setVisible(visible);
706   }
707
708   /**
709    * Especifica en que posición relativa a las métricas se ubica la métrica del nombre especificado.
710    * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
711    * @param name
712    * @param order
713    * @throws com.calipso.reportgenerator.common.InfoException
714    */
715   public void setMetricOrder(String name, int order) throws InfoException {
716     QueryMetric queryMetric = getQueryMetricFromName(name);
717     queryMetric.setMetricOrder(order);
718     if (order <= 0) {
719       metricOrderUpdated(name, order);
720     }
721   }
722
723
724   /**
725    * Reacomoda las métricas cuando cambia el orden
726    * @param name
727    * @param order
728    */
729
730   private void metricOrderUpdated(String name, int order) {
731     for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
732       QueryMetric queryMetric = (QueryMetric) iterator.next();
733       if (name != queryMetric.getName() && queryMetric.getMetricOrder() >= order) {
734         queryMetric.setMetricOrder(queryMetric.getMetricOrder() + 1);
735       }
736     }
737   }
738
739   /**
740    * Especifica todas las propiedades de la métrica que afectan a la query
741    * @param name
742    * @param visible para mostrar u ocultar los valores de la métrica
743    * @param order posición relativa a las métricas (si se quiere conservar el valor anterior parar el valor -1)
744    * @throws com.calipso.reportgenerator.common.InfoException
745    */
746   public void setMetricProperties(String name, boolean visible, int order) throws InfoException {
747     QueryMetric queryMetric = getQueryMetricFromName(name);
748     queryMetric.setMetricProperties(visible, order);
749     if (order <= 0) {
750       metricOrderUpdated(name, order);
751     }
752   }
753
754   /**
755    * Devuelve una métrica(<code>QueryMetric</code>) a partir de su nombre
756    * @param name
757    * @return
758    * @throws com.calipso.reportgenerator.common.InfoException
759    */
760   public QueryMetric getQueryMetricFromName(String name) throws InfoException {
761     for (int i = 0; i < getMetrics().size(); i++) {
762       QueryMetric queryMetric = (QueryMetric) getMetrics().get(i);
763       if (queryMetric.getName().equalsIgnoreCase(name)) {
764         return queryMetric;
765       }
766     }
767     throw new InfoException(MessageFormat.format(LanguageTraslator.traslate("83"), new Object []{name}));
768   }
769
770   /**
771    * Devuelve una dimensión (<code>QueryDimension</code>) a partir de su nombre
772    * @param name
773    * @return
774    * @throws com.calipso.reportgenerator.common.InfoException
775    */
776   public QueryDimension getQueryDimensionFromName(String name) throws InfoException {
777     for (int i = 0; i < getDimensions().size(); i++) {
778       QueryDimension queryDimension = (QueryDimension) getDimensions().get(i);
779       if (queryDimension.getName().equalsIgnoreCase(name)) {
780         return queryDimension;
781       }
782     }
783     throw new InfoException(MessageFormat.format(LanguageTraslator.traslate("84"), new Object []{name}));
784   }
785
786
787   /**
788    * Se utiliza para verificar si las propiedades asignadas a las dimensiones y a las métricas determinan una query válida
789    * @return
790    */
791   public boolean isValid() {
792     return getVisibleMetrics().size() > 0;
793   }
794
795   /** Devuelve los valores de parámetros especificados en la query, este método solo debería ser llamado desde la clase
796    * <Code>Report</Code> para la ejecución de la query, para especificar u obtener los valores de los parámetros de la
797    * query se deben utilizar los métodos <Code>getParamValue</Code> y <Code>setParamValue</Code>
798    * @return
799    */
800   public Map getParamValues() {
801     if (paramValues == null) {
802       paramValues = initializeParamValues();
803     }
804     return paramValues;
805   }
806
807   private Map initializeParamValues() {
808     return ReportFilterBuilder.mergeParamValues(null, getReportSpec().getParamValues(false));
809   }
810
811   /** Devuelve el valor un parámetro
812    * @param key identificador del parámetro (nombre del filtro + nombre del parámetro)
813    * @return valor del parámetro
814    */
815
816   public Object getParamValue(String key) {
817     return getParamValues().get(key);
818   }
819
820   /** Devuelve el valor un parámetro
821    *
822    * @param filterName
823    * @param parameterName
824    * @return
825    */
826   public Object getParamValue(String filterName, String parameterName) {
827     return getParamValue(filterName, parameterName);
828   }
829
830   /** Especifica el valor de un parámetro
831    *
832    * @param key identificador del parámetro
833    * @param value valor del parámetro
834    */
835   public void setParamValue(String key, Object value) {
836     getParamValues().put(key, value);
837   }
838
839
840   /** Especifica el valor de un parámetro
841    *
842    * @param filterName
843    * @param parameterName
844    * @param value
845    */
846   public void setParamValue(String filterName, String parameterName, Object value) {
847     getParamValues().put(filterName + parameterName, value);
848   }
849
850   /**
851    * Especifica los valores de varios parámetros contenidos en <code>paramValues</code> que es un <code>Map</code>
852    * donde cada clave es el identificador de un parámetro y cada objeto asociado es el valor de un parámetro
853    * @param paramValues
854    */
855   public void setParamValues(Map paramValues) {
856     Iterator keys = paramValues.keySet().iterator();
857     while (keys.hasNext()) {
858       String key = (String ) keys.next();
859       setParamValue(key, paramValues.get(key));
860     }
861   }
862
863   /**
864    * devuelve un array que contiene
865    * @return
866    */
867   public int[] getGroupingDimensionsIndexArray() {
868     int[] groupingDimensions;
869     int[] rows = getCubeRowFields();
870     int[] cols = getCubeColumnFields();
871
872     int rowsLenght;
873     int columnsLenght;
874     int dimensionsLenght;
875     int index;
876
877     rowsLenght = rows.length;
878     columnsLenght = cols.length;
879     dimensionsLenght = rowsLenght + columnsLenght;
880     groupingDimensions = new int[dimensionsLenght];
881     for (index = 0; index < rowsLenght; ++index) {
882       groupingDimensions[index] = rows[index];
883     }
884     for (index = 0; index < columnsLenght; ++index) {
885       groupingDimensions[index + rowsLenght] = cols[index];
886     }
887     return groupingDimensions;
888   }
889
890
891   /**
892    * Construye un filtro de valores enumerados a excluir
893    * @return
894    */
895   public EnumerationCubeFilter getEnumFilter() {
896     EnumerationCubeFilter filter = EnumerationCubeFilter.excluding();
897     Iterator iterator = getDimensionFilterValues().entrySet().iterator();
898     while (iterator.hasNext()) {
899       Map.Entry entry = (Map.Entry) iterator.next();
900       filter.addTo((Set) entry.getValue(), ((Integer ) entry.getKey()).intValue());
901     }
902     return filter;
903   }
904
905   /**
906    * Construye un filtro (post-filtro) a partir de las definiciones de filtro de la definición de reporte y los valores
907    * de los parámetros enviados por el usuario
908    * @param params
909    * @return
910    */
911   protected ExpressionCubeFilter getCubeFilter(Map params) throws InfoException {
912     try {
913       ReportFilterBuilder filterBuilder = new ReportFilterBuilder(getFilterDefinitions(), params, ReportFilterBuilder.VARMODE_INDEX);
914       return filterBuilder.getCubeFilter(getReportSpec(), null);
915     } catch (Exception e) {
916       throw new InfoException(LanguageTraslator.traslate("85"), e);
917     }
918   }
919
920   /**
921    * Devuelve las definiciones de filtros de la definición del Reporte
922    * @return
923    * @throws com.calipso.reportgenerator.common.InfoException
924    */
925   protected List getFilterDefinitions() throws InfoException {
926     if (filterDefinitions == null) {
927       filterDefinitions = new ArrayList();
928       Collection filterSpecs = getReportSpec().getFilterSpecs();
929       ReportFilter maxRowsFilter = getMaxRowsFilter();
930       if (maxRowsFilter != null) {
931         filterDefinitions.add(maxRowsFilter);
932       }
933       for (Iterator iterator = filterSpecs.iterator(); iterator.hasNext();) {
934         ReportFilterSpec reportFilterSpec = (ReportFilterSpec) iterator.next();
935         ReportFilter reportFilter = new ReportFilter(reportFilterSpec);
936         filterDefinitions.add(reportFilter);
937       }
938     }
939     return filterDefinitions;
940   }
941
942   /**
943    * Devuelve el filtro para recuperar la información de la matriz por lotes de una cantidad fija
944    * @return
945    */
946   private ReportFilter getMaxRowsFilter() {
947     ReportFilter maxRowsFilter = null;
948     ReportFilterSpec maxRowsFilterSpec = getReportSpec().getMaxRowsFilterSpec();
949     if (maxRowsFilterSpec != null) {
950       maxRowsFilter = new ReportFilter(maxRowsFilterSpec);
951     }
952     return maxRowsFilter;
953   }
954
955
956   /**
957    * Deveulve los valores de una dimension excluidos para el filtro enumerado
958    * @return
959    */
960   protected Map getDimensionFilterValues() {
961     if (dimensionFilterValues == null) {
962       dimensionFilterValues = new HashMap();
963     }
964     return dimensionFilterValues;
965   }
966
967   /**
968    * Devuelve la query traducida a la forma que utiliza el módulo de cálculo de reportes estáticos.
969    * @return
970    * @throws com.calipso.reportgenerator.common.InfoException
971    */
972   public StaticQuery getStaticQuery() throws InfoException {
973     try {
974       StaticQuery query = new StaticQuery();
975       int[] group = getStaticGroupingDimensions();
976       int[] noGroup = getStaticNonGroupingDimensions();
977       int[] metrics = getCubeMetricFields();
978       int[] accumulableMetrics = getStaticAccumulableMetricFields();
979       boolean[] ascending = getDimensionOrder();
980       query.setFilter(getCubeFilter(getParamValues()));
981       query.setGroupDimensions(group);
982       query.setNoGroupDimensions(noGroup);
983       query.setMetrics(metrics);
984       query.setAccumulableMetrics(accumulableMetrics);
985       query.setAscending(ascending);
986       query.setRankingFilter(getRankingFilter());
987
988 // query.setFilter(getCubeFilter(getParamValues()));
989 return query;
990     } catch (Exception e) {
991       throw new InfoException(LanguageTraslator.traslate("86"), e);
992     }
993   }
994
995   /**
996    * Devuelve los indices de las dimensiones que No agrupan
997    * @return
998    */
999   private int[] getStaticNonGroupingDimensions() {
1000    return getDimensionIndexArray(getDimensionsByGrouping(false));
1001  }
1002
1003  /**
1004   * Devuelve los indices de las dimensiones que agrupan
1005   */
1006
1007
1008  private int[] getStaticGroupingDimensions() {
1009    return getDimensionIndexArray(getDimensionsByGrouping(true));
1010  }
1011
1012  /**
1013   * Deveulve una lista con las dimensiones segun su rol en la agrupación
1014   * @param groups
1015   * @return
1016   */
1017
1018  private List getDimensionsByGrouping(boolean groups) {
1019
1020    List list = new ArrayList();
1021    for (Iterator iterator = getDimensions().iterator(); iterator.hasNext();) {
1022      QueryDimension queryDimension = (QueryDimension) iterator.next();
1023      if (queryDimension.getGroups() == groups) {
1024        (list).add(queryDimension);
1025      }
1026    }
1027    Collections.sort(list, new Comparator() {
1028      public int compare(Object o1, Object o2) {
1029        QueryDimension dim1 = (QueryDimension) o1;
1030        QueryDimension dim2 = (QueryDimension) o2;
1031        return dim1.getLocationOrder() - dim2.getLocationOrder();
1032      }
1033    });
1034    return list;
1035  }
1036
1037
1038  /**
1039   * Devuelve la lista de valores de dimension excluidos para el filtro enumerado
1040   * @param dimension
1041   * @return
1042   */
1043  private Set getDimensionFilterValuesFor(int dimension) {
1044    Integer key = new Integer (dimension);
1045    Set values = (Set) getDimensionFilterValues().get(key);
1046    if (values == null) {
1047      values = new TreeSet();
1048      getDimensionFilterValues().put(key, values);
1049    }
1050    return values;
1051
1052  }
1053
1054  /**
1055   * Agrega un nuevo valor de dimension excluido
1056   * @param dimension
1057   * @param value
1058   */
1059  public void excludeValue(int dimension, Object value) {
1060    Set values = getDimensionFilterValuesFor(dimension);
1061    values.add(value);
1062  }
1063
1064  /**
1065   * Elimina un valor de dimension excluido
1066   * @param dimension
1067   * @param value
1068   */
1069
1070  public void includeValue(int dimension, Object value) {
1071    Set values = getDimensionFilterValuesFor(dimension);
1072    values.remove(value);
1073  }
1074
1075  /**
1076   * Asocia una lista de valores excluidos a una dimensión
1077   * @param dimension
1078   * @param excludedValues
1079   */
1080  public void setExcludedValues(int dimension, Collection excludedValues) {
1081    getDimensionFilterValues().put(new Integer (dimension), excludedValues);
1082  }
1083
1084  /**
1085   * Deveuelve la lista de valores excluidos de una dimensión
1086   * @param dimension
1087   * @return
1088   */
1089  public Set getExcludedValues(int dimension) {
1090    return (Set) getDimensionFilterValues().get(new Integer (dimension));
1091  }
1092
1093  public boolean isVisibleTotals() {
1094    return visibleTotals;
1095  }
1096
1097  public void setVisibleTotals(boolean visibleTotals) {
1098    this.visibleTotals = visibleTotals;
1099  }
1100
1101  /**
1102   * Setea las metricas como visibles
1103   * @param otherMetrics
1104   */
1105  private void setMetricsVisible(Collection otherMetrics) {
1106    for (Iterator iterator = otherMetrics.iterator(); iterator.hasNext();) {
1107      QueryMetric queryMetric = (QueryMetric) iterator.next();
1108      queryMetric.setVisible(true);
1109    }
1110  }
1111
1112  /**
1113   * Agrega las dimensiones a las QueryDimensions
1114   * @param otherDimensions
1115   */
1116  private void addDimensions(Collection otherDimensions) {
1117    getDimensions().addAll(otherDimensions);
1118  }
1119
1120  /**
1121   * Setea como unica metrica visible la especificada
1122   * @param rankMetricName
1123   */
1124  public void setUniqueMetricVisible(String rankMetricName) {
1125    if(rankMetricName!=null && !rankMetricName.equalsIgnoreCase("")){
1126      List metrics = getMetrics();
1127      Iterator iter = metrics.iterator();
1128      while(iter.hasNext()){
1129        QueryMetric metric = (QueryMetric)iter.next();
1130        //Solo es visible si su nombre es el especificado
1131 if(metric.getName().equalsIgnoreCase(rankMetricName)){
1132          metric.setVisible(true);
1133        }else{
1134          metric.setVisible(false);
1135        }
1136      }
1137    }
1138  }
1139
1140  /**
1141   * Agrega los filtros especificados al report spec.
1142   * @param filters
1143   */
1144  public void addFilters(Collection filters) {
1145    Iterator iter = filters.iterator();
1146    while(iter.hasNext()){
1147      getReportSpec().getFilterSpecs().add(iter.next());
1148    }
1149  }
1150
1151  /**
1152   * Quita los filtros especificados del report spec
1153   * @param filters
1154   */
1155  public void removeFilters(Collection filters) {
1156    Iterator iter = filters.iterator();
1157    while(iter.hasNext()){
1158      getReportSpec().getFilterSpecs().remove(iter.next());
1159    }
1160  }
1161
1162  public EnumerationCubeFilter getRankingFilter() {
1163    if(rankingFilter==null){
1164      rankingFilter = EnumerationCubeFilter.including();
1165    }
1166    return rankingFilter;
1167  }
1168
1169  /**
1170   * Setea la dimension como unica visible para la query
1171   * @param dimension
1172   */
1173  public void setUniqueDimension(ReportDimensionSpec dimension) {
1174    List dimensions = getDimensions();
1175    String name = dimension.getName();
1176    Iterator iterator = dimensions.iterator();
1177    while(iterator.hasNext()){
1178      QueryDimension dim = (QueryDimension)iterator.next();
1179      if(dim.getName().equalsIgnoreCase(name)){
1180        dim.setLocation(DimensionDefinitionLocationType.ROW);
1181        dim.setGroups(true);
1182      }else{
1183        dim.setLocation(DimensionDefinitionLocationType.HIDDEN);
1184        dim.setGroups(false);
1185      }
1186    }
1187  }
1188
1189  public EnumerationCubeFilter getExcludeGroupFilter() {
1190    if(excludeGroupFilter==null){
1191      excludeGroupFilter = EnumerationCubeFilter.including();
1192    }
1193    return excludeGroupFilter;
1194  }
1195
1196  public void setExcludeGroupFilter(EnumerationCubeFilter excludeGroupFilter) {
1197    this.excludeGroupFilter = excludeGroupFilter;
1198  }
1199}
1200

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags