001: package com.calipso.reportgenerator.common;
002:
003: import com.calipso.reportgenerator.reportdefinitions.DimensionSourceDefinition;
004: import com.calipso.reportgenerator.reportdefinitions.DimensionDefinition;
005: import com.calipso.reportgenerator.reportdefinitions.types.DimensionDefinitionLocationType;
006: import com.calipso.reportgenerator.reportdefinitions.types.DimensionDefinitionOrderType;
007: import com.calipso.reportgenerator.reportdefinitions.types.ReportDataType;
008: import com.calipso.reportgenerator.reportcalculator.SharedDate;
009: import com.calipso.reportgenerator.reportcalculator.SharedFloat;
010: import com.calipso.reportgenerator.reportcalculator.SharedInteger;
011: import com.calipso.common.DateEx;
012: import java.util.Date;
013: import java.util.Map;
014:
015: /**
016: * Representa a una Dimensión de un reporte conteniendo la información del ReportDefinition y su ReportSourceDefinition
017: * asociado para la ejecución de un reporte.
018: */
019: public class ReportDimensionSpec extends ReportFieldSpec {
020:
021: private String expression;
022: private String groupFooterCaption;
023: private DimensionDefinitionLocationType location;
024: private DimensionDefinitionOrderType order;
025: private ReportDataType dataType;
026: private boolean groups;
027: private String datePattern;
028: private String referencedDimensionName;
029: private int referencedDataIndex;
030: private String dateFunction;
031: private String rankMetricName;
032: private String dateTimePattern;
033: private boolean indexed;
034:
035: //private String queryConvertToStringPattern;
036:
037: /**
038: * Constructor de la super clase, que además asigna los valores por defecto específicos de esta clase
039: * @param name
040: */
041: public ReportDimensionSpec(String name) {
042: super (name);
043: referencedDataIndex = -1;
044: referencedDimensionName = null;
045: dateFunction = null;
046: }
047:
048: /**
049: * Inicializa los valores de los atributos a partir de un DimensionSourceDefinition
050: * @param dimensionSourceDefinition
051: * @param isMultilanguaje
052: * @param localization
053: */
054: public void fillFrom(
055: DimensionSourceDefinition dimensionSourceDefinition,
056: boolean isMultilanguaje, Map localization) {
057: setCaption(resolveCaption(isMultilanguaje, localization,
058: dimensionSourceDefinition.getDescription()));
059: setCalculated(dimensionSourceDefinition.getCalculated());
060: setExpression(dimensionSourceDefinition.getExpression());
061: setExternalData(dimensionSourceDefinition.getExternalData());
062: setDataType(dimensionSourceDefinition.getDataType());
063: setIndexed(dimensionSourceDefinition.getIndexed());
064: //setQueryConvertToStringPattern(dimensionSourceDefinition.getQueryConvertToStringPattern());
065: }
066:
067: /**
068: * Inicializa los valores de los atributos a partir de un DimensionDefinition
069: * @param dimensionDefinition
070: * @param isMultilanguaje
071: * @param localization
072: */
073: public void fillFrom(DimensionDefinition dimensionDefinition,
074: boolean isMultilanguaje, Map localization) {
075: if ((dimensionDefinition.getDescription() != null)
076: && !("").equals(dimensionDefinition.getDescription())) {
077: setCaption(resolveCaption(isMultilanguaje, localization,
078: dimensionDefinition.getDescription()));
079: }
080: setGroupFooterCaption(resolveCaption(isMultilanguaje,
081: localization, dimensionDefinition
082: .getGroupFooterCaption()));
083: setLocation(dimensionDefinition.getLocation());
084: setOrder(dimensionDefinition.getOrder());
085: setGroups(dimensionDefinition.getGroups());
086: setInReportDefinition(true);
087: setRankMetricName(dimensionDefinition.getRankMetricName());
088: }
089:
090: /**
091: * Espresión que se utiliza para resolver la dimensión calculada
092: * @return
093: */
094: public String getExpression() {
095: return expression;
096: }
097:
098: /**
099: * Asigna la expresion que se utiliza para resolver las dimensión calculada
100: * @param expression
101: */
102: public void setExpression(String expression) {
103: this .expression = expression;
104: }
105:
106: /**
107: * Título del pie del grupo
108: * @return
109: */
110: public String getGroupFooterCaption() {
111: return groupFooterCaption;
112: }
113:
114: /**
115: * Asigna Título del pie del grupo
116: * @param groupFooterCaption
117: */
118:
119: public void setGroupFooterCaption(String groupFooterCaption) {
120: this .groupFooterCaption = groupFooterCaption;
121: }
122:
123: /**
124: * Asigna el tipo de ordenamiento por defecto para la dimension
125: * @return
126: */
127: public DimensionDefinitionOrderType getOrder() {
128: if (order == null) {
129: return DimensionDefinitionOrderType.A;
130: }
131: return order;
132: }
133:
134: /**
135: * Asigna el tipo de ordenamiento por defecto para la dimension
136: * @param order
137: */
138: public void setOrder(DimensionDefinitionOrderType order) {
139: this .order = order;
140: }
141:
142: /**
143: * Especifica la ubicación en el reporte de la dimension, solo se utiliza en los reportes tupo Cubo, para especificar
144: * si la dimension agrupa por fila, por columna o no interviene en la agrupación
145: * @return
146: */
147: public DimensionDefinitionLocationType getLocation() {
148: return location;
149: }
150:
151: /**
152: * Asigna la ubicación de agrupación
153: * @param location
154: */
155: public void setLocation(DimensionDefinitionLocationType location) {
156: this .location = location;
157: }
158:
159: /**
160: * Tipo de dato de los valores de la dimensión
161: * @return
162: */
163: public ReportDataType getDataType() {
164: return dataType;
165: }
166:
167: /**
168: * Asigna el tipo de dato de los valores de la dimension
169: * @param dataType
170: */
171: public void setDataType(ReportDataType dataType) {
172: this .dataType = dataType;
173: }
174:
175: /**
176: * Devuelve verdadero si el atributo agrupa (genera grupos en el reporte), sirve para los reportes estáticos y
177: * sumarizados
178: * @return
179: */
180: public boolean getGroups() {
181: return groups;
182: }
183:
184: /**
185: * Espefica si la dimensión intervine en la agrupación
186: * @param groups
187: */
188: public void setGroups(boolean groups) {
189: this .groups = groups;
190: }
191:
192: /**
193: * Se utiliaza para resolver la dimensión en base a la que se calculará una dimension Calculada
194: * @param referencedName
195: * @return
196: */
197: protected int getReferencedDataIndex(String referencedName) {
198: if (referencedDataIndex == -1) {
199: referencedDataIndex = getReportSourceIndexFromName(referencedName);
200: }
201: return referencedDataIndex;
202: }
203:
204: private int getReportSourceIndexFromName(String referencedName) {
205: return ((Integer) getReportSourceIndexes().get(referencedName))
206: .intValue();
207: }
208:
209: /**
210: * Obtiene el nombre de la dimensión en base a la que se calcula, parseando la expresión de cálculo
211: * @return
212: */
213: protected String getReferencedDimensionName() {
214: if (referencedDimensionName == null) {
215: DateExpressionParser expressionParser = new DateExpressionParser();
216: expressionParser.setExpression(getExpression());
217: referencedDimensionName = expressionParser.getFieldName();
218: }
219: return referencedDimensionName;
220: }
221:
222: /**
223: * Devuelve la función de fecha que se debe utilizar para calcular, parseando la expresión de cálculo
224: * @return
225: */
226: protected String getDateFunction() {
227: if (dateFunction == null) {
228: DateExpressionParser expressionParser = new DateExpressionParser();
229: expressionParser.setExpression(getExpression());
230: dateFunction = expressionParser.getDateFunction();
231: }
232: return dateFunction;
233: }
234:
235: /**
236: * Devuelve el pattern para tratar el tipo de datos DATE
237: * @return
238: *
239: public String getDatePattern() {
240: return datePattern;
241: }
242:
243: /**
244: * Asigna el pattern para tratar el tipo de datos DATE
245: * @param datePattern
246: *
247: public void setDatePattern(String datePattern) {
248: this.datePattern = datePattern;
249: }
250:
251: /**
252: * Devuelve el pattern para tratar el tipo de datos DATETIME
253: * @return
254: *
255: public String getDateTimePattern() {
256: return dateTimePattern;
257: }
258:
259: /**
260: * Asigna el pattern para tratar el tipo de datos DATETIME
261: * @param dateTimePattern
262: *
263: public void setDateTimePattern(String dateTimePattern) {
264: this.dateTimePattern = dateTimePattern;
265: }*/
266:
267: /**
268: * 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
269: * métrica. Si este valor no está asignado, el ordenamiento se realiza en base a los valores de la dimensión
270: * @return
271: */
272: public String getRankMetricName() {
273: return rankMetricName;
274: }
275:
276: /**
277: * Asigna el nombre de la métrica en base a cuyos valores se debe ordenar
278: * @param rankMetricName
279: */
280: public void setRankMetricName(String rankMetricName) {
281: this .rankMetricName = rankMetricName;
282: }
283:
284: /**
285: * Resulve la obtención del valor proveniente del IDataSource, obteniendo el valor directo en las dimensiones simples y
286: * aplicando la expresión de cálculo en las dimensiones calculadas
287: * @param dataSource
288: * @param index
289: * @param dataSourceSpec
290: * @return
291: * @throws com.calipso.reportgenerator.common.InfoException
292: */
293: public Object getValue(Object[] rowValues,
294: ReportDataSourceSpec dataSourceSpec) throws InfoException {
295: try {
296: if (getCalculated()) {
297: String refDimensionName = getReferencedDimensionName();
298: int calcDataIndex = getReferencedDataIndex(refDimensionName);
299: Object date = rowValues[calcDataIndex];
300: if ((date instanceof SharedDate)) {
301: String resultValue = DateExpressionResolver
302: .Resolve(getDateFunction(),
303: ((SharedDate) date).getDateEx()
304: .getDate());
305: return SharedInteger.newFrom(Integer
306: .valueOf(resultValue));
307: } else if (date instanceof Date) {
308: String resultValue = DateExpressionResolver
309: .Resolve(getDateFunction(), ((Date) date));
310: return SharedInteger.newFrom(Integer
311: .valueOf(resultValue));
312: } else {
313: String dateString = date.toString();
314: String resultValue = DateExpressionResolver
315: .Resolve(getDateFunction(), dateString,
316: dataSourceSpec.getPattern(this
317: .getDataType().getType()));
318: return SharedInteger.newFrom(Integer
319: .valueOf(resultValue));
320: }
321: } else {
322: return convertValue(rowValues[getReportSourceIndex()],
323: dataSourceSpec.getPattern(this .getDataType()
324: .getType()));
325: }
326: } catch (Exception e) {
327: throw new InfoException(LanguageTraslator.traslate("80"), e);
328: }
329: }
330:
331: /*public String getPattern(int type) {
332: switch(type){
333: case DimensionSourceDefinitionDataTypeType.DATE_TYPE:
334: return getDatePattern();
335: case DimensionSourceDefinitionDataTypeType.DATETIME_TYPE:
336: return getDateTimePattern();
337: default:
338: return "";
339: }
340: }*/
341:
342: /**
343: * Convierte los datos de entrada al tipo de dato real definido
344: *
345: * @return
346: */
347: private Object convertValue(Object value, String datePattern)
348: throws InfoException {
349: if (getDataType().getType() == ReportDataType.DATETIME_TYPE
350: || getDataType().getType() == ReportDataType.DATE_TYPE) {
351: if (value instanceof SharedDate) {
352: return value;
353: } else if (value instanceof DateEx) {
354: return SharedDate.newFrom((DateEx) value);
355: } else {
356: return SharedDate
357: .newFrom(new DateEx(value, datePattern));
358: }
359: } else {
360: return value;
361: }
362: }
363:
364: /*
365: * Retorna el valor para mostrar formateado
366: * @param currentValue
367: * @return
368: *
369: public Object getVisualValue(Object currentValue) {
370: if (getDataType().getType() == DimensionSourceDefinitionDataTypeType.DATETIME_TYPE){
371: SimpleDateFormat dateFormat = new SimpleDateFormat(getDatePattern());
372: return new String(dateFormat.format(((Date)currentValue)));
373: } else {
374: return currentValue;
375: }
376: }*/
377:
378: /*public String getQueryConvertToStringPattern() {
379: return queryConvertToStringPattern;
380: }
381:
382: public void setQueryConvertToStringPattern(String queryConvertToStringPattern) {
383: this.queryConvertToStringPattern = queryConvertToStringPattern;
384: }*/
385:
386: /**
387: * Convierte un valor a el tipo de dato correspondiente a esta dimension
388: * @param value
389: * @return
390: * @throws InfoException
391: */
392: public Object getValueFor(Object value) throws InfoException {
393: return getValueFor(value, dataType.getType());
394: }
395:
396: public static Object getValueFor(Object value, int dataType)
397: throws InfoException {
398: if (value instanceof String) {
399: try {
400: String strValue = value.toString();
401: switch (dataType) {
402: case ReportDataType.BOOLEAN_TYPE:
403: return new Boolean(strValue);
404: case ReportDataType.FLOAT_TYPE:
405: return SharedFloat.newFrom(new Float(strValue));
406: case ReportDataType.STRING_TYPE:
407: return strValue;
408: case ReportDataType.INTEGER_TYPE:
409: return SharedInteger.newFrom(new Integer(strValue));
410: case ReportDataType.DATETIME_TYPE:
411: case ReportDataType.DATE_TYPE:
412: return SharedDate.newFrom(new DateEx(value));
413: }
414: } catch (Exception e) {
415: throw new InfoException(LanguageTraslator
416: .traslate("361"), e);
417: }
418: } else if (value instanceof Date) {
419: if (dataType == ReportDataType.DATETIME_TYPE
420: || dataType == ReportDataType.DATE_TYPE) {
421: return SharedDate.newFrom(new DateEx((Date) value));
422: } else {
423: throw new InfoException(LanguageTraslator
424: .traslate("361"));
425: }
426: }
427: return value;
428: }
429:
430: public boolean isIndexed() {
431: return indexed;
432: }
433:
434: public void setIndexed(boolean indexed) {
435: this.indexed = indexed;
436: }
437:
438: }
|