KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.calipso.reportgenerator.common;
2
3 import com.calipso.reportgenerator.reportdefinitions.DimensionSourceDefinition;
4 import com.calipso.reportgenerator.reportdefinitions.DimensionDefinition;
5 import com.calipso.reportgenerator.reportdefinitions.types.DimensionDefinitionLocationType;
6 import com.calipso.reportgenerator.reportdefinitions.types.DimensionDefinitionOrderType;
7 import com.calipso.reportgenerator.reportdefinitions.types.ReportDataType;
8 import com.calipso.reportgenerator.reportcalculator.SharedDate;
9 import com.calipso.reportgenerator.reportcalculator.SharedFloat;
10 import com.calipso.reportgenerator.reportcalculator.SharedInteger;
11 import com.calipso.common.DateEx;
12 import java.util.Date JavaDoc;
13 import java.util.Map JavaDoc;
14
15 /**
16  * Representa a una Dimensión de un reporte conteniendo la información del ReportDefinition y su ReportSourceDefinition
17  * asociado para la ejecución de un reporte.
18  */
19 public class ReportDimensionSpec extends ReportFieldSpec {
20
21   private String JavaDoc expression;
22   private String JavaDoc groupFooterCaption;
23   private DimensionDefinitionLocationType location;
24   private DimensionDefinitionOrderType order;
25   private ReportDataType dataType;
26   private boolean groups;
27   private String JavaDoc datePattern;
28   private String JavaDoc referencedDimensionName;
29   private int referencedDataIndex;
30   private String JavaDoc dateFunction;
31   private String JavaDoc rankMetricName;
32   private String JavaDoc dateTimePattern;
33   private boolean indexed;
34   //private String queryConvertToStringPattern;
35
36   /**
37    * Constructor de la super clase, que además asigna los valores por defecto específicos de esta clase
38    * @param name
39    */
40   public ReportDimensionSpec(String JavaDoc name) {
41     super(name);
42     referencedDataIndex = -1;
43     referencedDimensionName = null;
44     dateFunction = null;
45   }
46
47
48   /**
49    * Inicializa los valores de los atributos a partir de un DimensionSourceDefinition
50    * @param dimensionSourceDefinition
51    * @param isMultilanguaje
52    * @param localization
53    */
54   public void fillFrom(DimensionSourceDefinition dimensionSourceDefinition, boolean isMultilanguaje, Map JavaDoc localization) {
55     setCaption(resolveCaption(isMultilanguaje,localization,dimensionSourceDefinition.getDescription()));
56     setCalculated(dimensionSourceDefinition.getCalculated());
57     setExpression(dimensionSourceDefinition.getExpression());
58     setExternalData(dimensionSourceDefinition.getExternalData());
59     setDataType(dimensionSourceDefinition.getDataType());
60     setIndexed(dimensionSourceDefinition.getIndexed());
61     //setQueryConvertToStringPattern(dimensionSourceDefinition.getQueryConvertToStringPattern());
62 }
63
64 /**
65    * Inicializa los valores de los atributos a partir de un DimensionDefinition
66    * @param dimensionDefinition
67    * @param isMultilanguaje
68    * @param localization
69    */
70   public void fillFrom(DimensionDefinition dimensionDefinition, boolean isMultilanguaje, Map JavaDoc localization) {
71     if ((dimensionDefinition.getDescription() != null) && !("").equals(dimensionDefinition.getDescription())) {
72       setCaption(resolveCaption(isMultilanguaje,localization,dimensionDefinition.getDescription()));
73     }
74     setGroupFooterCaption(resolveCaption(isMultilanguaje,localization,dimensionDefinition.getGroupFooterCaption()));
75     setLocation(dimensionDefinition.getLocation());
76     setOrder(dimensionDefinition.getOrder());
77     setGroups(dimensionDefinition.getGroups());
78     setInReportDefinition(true);
79     setRankMetricName(dimensionDefinition.getRankMetricName());
80   }
81
82   /**
83    * Espresión que se utiliza para resolver la dimensión calculada
84    * @return
85    */
86   public String JavaDoc getExpression() {
87     return expression;
88   }
89
90   /**
91    * Asigna la expresion que se utiliza para resolver las dimensión calculada
92    * @param expression
93    */
94   public void setExpression(String JavaDoc expression) {
95     this.expression = expression;
96   }
97
98   /**
99    * Título del pie del grupo
100    * @return
101    */
102   public String JavaDoc getGroupFooterCaption() {
103     return groupFooterCaption;
104   }
105
106   /**
107    * Asigna Título del pie del grupo
108    * @param groupFooterCaption
109    */
110
111   public void setGroupFooterCaption(String JavaDoc groupFooterCaption) {
112     this.groupFooterCaption = groupFooterCaption;
113   }
114
115
116   /**
117    * Asigna el tipo de ordenamiento por defecto para la dimension
118    * @return
119    */
120   public DimensionDefinitionOrderType getOrder() {
121     if (order == null){
122       return DimensionDefinitionOrderType.A;
123     }
124     return order;
125   }
126
127
128   /**
129    * Asigna el tipo de ordenamiento por defecto para la dimension
130    * @param order
131    */
132   public void setOrder(DimensionDefinitionOrderType order) {
133     this.order = order;
134   }
135
136   /**
137    * Especifica la ubicación en el reporte de la dimension, solo se utiliza en los reportes tupo Cubo, para especificar
138    * si la dimension agrupa por fila, por columna o no interviene en la agrupación
139    * @return
140    */
141   public DimensionDefinitionLocationType getLocation() {
142     return location;
143   }
144
145   /**
146    * Asigna la ubicación de agrupación
147    * @param location
148    */
149   public void setLocation(DimensionDefinitionLocationType location) {
150     this.location = location;
151   }
152
153   /**
154    * Tipo de dato de los valores de la dimensión
155    * @return
156    */
157   public ReportDataType getDataType() {
158     return dataType;
159   }
160
161   /**
162    * Asigna el tipo de dato de los valores de la dimension
163    * @param dataType
164    */
165   public void setDataType(ReportDataType dataType) {
166     this.dataType = dataType;
167   }
168
169   /**
170    * Devuelve verdadero si el atributo agrupa (genera grupos en el reporte), sirve para los reportes estáticos y
171    * sumarizados
172    * @return
173    */
174   public boolean getGroups() {
175     return groups;
176   }
177
178   /**
179    * Espefica si la dimensión intervine en la agrupación
180    * @param groups
181    */
182   public void setGroups(boolean groups) {
183     this.groups = groups;
184   }
185
186   /**
187    * Se utiliaza para resolver la dimensión en base a la que se calculará una dimension Calculada
188    * @param referencedName
189    * @return
190    */
191   protected int getReferencedDataIndex(String JavaDoc referencedName){
192     if (referencedDataIndex == -1){
193       referencedDataIndex = getReportSourceIndexFromName(referencedName);
194     }
195     return referencedDataIndex;
196   }
197
198   private int getReportSourceIndexFromName(String JavaDoc referencedName) {
199     return ((Integer JavaDoc)getReportSourceIndexes().get(referencedName)).intValue();
200   }
201
202   /**
203    * Obtiene el nombre de la dimensión en base a la que se calcula, parseando la expresión de cálculo
204    * @return
205    */
206   protected String JavaDoc getReferencedDimensionName() {
207     if (referencedDimensionName == null){
208       DateExpressionParser expressionParser = new DateExpressionParser();
209       expressionParser.setExpression(getExpression());
210       referencedDimensionName = expressionParser.getFieldName();
211     }
212     return referencedDimensionName;
213   }
214
215   /**
216    * Devuelve la función de fecha que se debe utilizar para calcular, parseando la expresión de cálculo
217    * @return
218    */
219   protected String JavaDoc getDateFunction(){
220     if (dateFunction == null){
221       DateExpressionParser expressionParser = new DateExpressionParser();
222       expressionParser.setExpression(getExpression());
223       dateFunction = expressionParser.getDateFunction();
224     }
225     return dateFunction;
226   }
227
228   /**
229    * Devuelve el pattern para tratar el tipo de datos DATE
230    * @return
231    *
232   public String getDatePattern() {
233     return datePattern;
234   }
235
236   /**
237    * Asigna el pattern para tratar el tipo de datos DATE
238    * @param datePattern
239    *
240   public void setDatePattern(String datePattern) {
241     this.datePattern = datePattern;
242   }
243
244   /**
245    * Devuelve el pattern para tratar el tipo de datos DATETIME
246    * @return
247    *
248   public String getDateTimePattern() {
249     return dateTimePattern;
250   }
251
252   /**
253    * Asigna el pattern para tratar el tipo de datos DATETIME
254    * @param dateTimePattern
255    *
256   public void setDateTimePattern(String dateTimePattern) {
257     this.dateTimePattern = dateTimePattern;
258   }*/
259
260   /**
261    * En caso que la dimensión se ordene en base al valor de una métrica, en este atributo se especifica el nombre de dicha
262    * métrica. Si este valor no está asignado, el ordenamiento se realiza en base a los valores de la dimensión
263    * @return
264    */
265   public String JavaDoc getRankMetricName() {
266     return rankMetricName;
267   }
268
269   /**
270    * Asigna el nombre de la métrica en base a cuyos valores se debe ordenar
271    * @param rankMetricName
272    */
273   public void setRankMetricName(String JavaDoc rankMetricName) {
274     this.rankMetricName = rankMetricName;
275   }
276
277   /**
278    * Resulve la obtención del valor proveniente del IDataSource, obteniendo el valor directo en las dimensiones simples y
279    * aplicando la expresión de cálculo en las dimensiones calculadas
280    * @param dataSource
281    * @param index
282    * @param dataSourceSpec
283    * @return
284    * @throws com.calipso.reportgenerator.common.InfoException
285    */
286   public Object JavaDoc getValue(Object JavaDoc[] rowValues, ReportDataSourceSpec dataSourceSpec) throws InfoException {
287     try {
288       if (getCalculated()) {
289         String JavaDoc refDimensionName = getReferencedDimensionName();
290         int calcDataIndex = getReferencedDataIndex(refDimensionName);
291         Object JavaDoc date = rowValues[calcDataIndex];
292         if ((date instanceof SharedDate)){
293           String JavaDoc resultValue = DateExpressionResolver.Resolve(getDateFunction(),((SharedDate)date).getDateEx().getDate());
294           return SharedInteger.newFrom(Integer.valueOf(resultValue));
295         } else if (date instanceof Date){
296           String JavaDoc resultValue = DateExpressionResolver.Resolve(getDateFunction(),((Date)date));
297           return SharedInteger.newFrom(Integer.valueOf(resultValue));
298         } else{
299           String JavaDoc dateString = date.toString();
300           String JavaDoc resultValue = DateExpressionResolver.Resolve(getDateFunction(), dateString, dataSourceSpec.getPattern(this.getDataType().getType()));
301           return SharedInteger.newFrom(Integer.valueOf(resultValue));
302         }
303       } else {
304         return convertValue(rowValues[getReportSourceIndex()], dataSourceSpec.getPattern(this.getDataType().getType()));
305       }
306     } catch (Exception JavaDoc e) {
307       throw new InfoException(LanguageTraslator.traslate("80"), e);
308     }
309   }
310
311   /*public String getPattern(int type) {
312     switch(type){
313       case DimensionSourceDefinitionDataTypeType.DATE_TYPE:
314         return getDatePattern();
315       case DimensionSourceDefinitionDataTypeType.DATETIME_TYPE:
316         return getDateTimePattern();
317       default:
318         return "";
319     }
320   }*/
321
322   /**
323    * Convierte los datos de entrada al tipo de dato real definido
324    *
325    * @return
326    */
327   private Object JavaDoc convertValue(Object JavaDoc value, String JavaDoc datePattern) throws InfoException {
328     if (getDataType().getType() == ReportDataType.DATETIME_TYPE || getDataType().getType() == ReportDataType.DATE_TYPE){
329       if(value instanceof SharedDate){
330         return value;
331       }else if(value instanceof DateEx){
332         return SharedDate.newFrom((DateEx)value);
333       }else{
334         return SharedDate.newFrom(new DateEx(value, datePattern));
335       }
336     } else {
337       return value;
338     }
339   }
340
341
342
343   /*
344    * Retorna el valor para mostrar formateado
345    * @param currentValue
346    * @return
347    *
348   public Object getVisualValue(Object currentValue) {
349     if (getDataType().getType() == DimensionSourceDefinitionDataTypeType.DATETIME_TYPE){
350       SimpleDateFormat dateFormat = new SimpleDateFormat(getDatePattern());
351       return new String(dateFormat.format(((Date)currentValue)));
352     } else {
353       return currentValue;
354     }
355   }*/
356
357   /*public String getQueryConvertToStringPattern() {
358     return queryConvertToStringPattern;
359   }
360
361   public void setQueryConvertToStringPattern(String queryConvertToStringPattern) {
362     this.queryConvertToStringPattern = queryConvertToStringPattern;
363   }*/
364
365   /**
366    * Convierte un valor a el tipo de dato correspondiente a esta dimension
367    * @param value
368    * @return
369    * @throws InfoException
370    */
371   public Object JavaDoc getValueFor(Object JavaDoc value) throws InfoException {
372     return getValueFor(value, dataType.getType());
373   }
374
375   public static Object JavaDoc getValueFor(Object JavaDoc value, int dataType) throws InfoException{
376     if(value instanceof String JavaDoc){
377       try {
378         String JavaDoc strValue = value.toString();
379         switch(dataType){
380           case ReportDataType.BOOLEAN_TYPE:
381             return new Boolean JavaDoc(strValue);
382           case ReportDataType.FLOAT_TYPE:
383             return SharedFloat.newFrom(new Float JavaDoc(strValue));
384           case ReportDataType.STRING_TYPE:
385             return strValue;
386           case ReportDataType.INTEGER_TYPE:
387             return SharedInteger.newFrom(new Integer JavaDoc(strValue));
388           case ReportDataType.DATETIME_TYPE:
389           case ReportDataType.DATE_TYPE:
390             return SharedDate.newFrom(new DateEx(value));
391         }
392       } catch (Exception JavaDoc e) {
393           throw new InfoException(LanguageTraslator.traslate("361"), e);
394       }
395     } else if(value instanceof Date) {
396       if(dataType == ReportDataType.DATETIME_TYPE || dataType == ReportDataType.DATE_TYPE){
397         return SharedDate.newFrom(new DateEx((Date)value));
398       } else {
399         throw new InfoException(LanguageTraslator.traslate("361"));
400       }
401     }
402     return value;
403   }
404
405   public boolean isIndexed() {
406     return indexed;
407   }
408
409   public void setIndexed(boolean indexed) {
410     this.indexed = indexed;
411   }
412
413 }
414
415
Popular Tags