001: package com.calipso.reportgenerator.common;
002:
003: import com.calipso.reportgenerator.reportdefinitions.types.FilterDefinitionFilterTypeType;
004: import com.calipso.reportgenerator.reportcalculator.expression.*;
005: import com.calipso.reportgenerator.common.ReportSpec;
006: import com.calipso.reportgenerator.common.ReportFilterSpec;
007: import com.calipso.reportgenerator.common.ReportDimensionSpec;
008:
009: import java.util.*;
010: import java.io.Serializable;
011:
012: /**
013: * Es el filtro de un reporte. Incluye todos los filtros como una sola expreción. Se utiliza para evaluar en linea u obtener los textos(SQL,OQL) para filtrar otros origenes de datos
014: */
015:
016: public class ReportFilter implements Serializable {
017:
018: private ReportFilterSpec filterSpec;
019:
020: /**
021: * Crea e inicializa un report filter
022: * @param filterSpec
023: */
024: public ReportFilter(ReportFilterSpec filterSpec) {
025: this .filterSpec = filterSpec;
026: }
027:
028: /**
029: * Devuelve el filter definition
030: * @return
031: */
032: public ReportFilterSpec getFilterSpec() {
033: return filterSpec;
034: }
035:
036: /**
037: * Devuelve una expression dependiendo del tipo de filtro
038: * @param paramValues Lista de parameters value para componer la exrescion
039: * @param mode Modo nombre de variables
040: * @return
041: */
042: public Expression getExpression(Map paramValues, int mode,
043: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
044: ReportFilter reportFilter) throws InfoException {
045:
046: switch (getFilterSpec().getFilterType().getType()) {
047: case FilterDefinitionFilterTypeType.RANGE_TYPE:
048: return getRangeExp(paramValues, mode, reportSpec,
049: dataSourceSpec, reportFilter);
050: case FilterDefinitionFilterTypeType.GREATERTHAN_TYPE:
051: return getGraterThanExp(paramValues, mode, reportSpec,
052: dataSourceSpec, reportFilter);
053: case FilterDefinitionFilterTypeType.LESSTHAN_TYPE:
054: return getLessThanExp(paramValues, mode, reportSpec,
055: dataSourceSpec, reportFilter);
056: case FilterDefinitionFilterTypeType.EQUALTO_TYPE:
057: return getEqualToExp(paramValues, mode, reportSpec,
058: dataSourceSpec, reportFilter);
059: case FilterDefinitionFilterTypeType.BEGINWITH_TYPE:
060: return getBeginWithExp(paramValues, mode, reportSpec,
061: dataSourceSpec, reportFilter);
062: case FilterDefinitionFilterTypeType.ENDWITH_TYPE:
063: return getEndWithExp(paramValues, mode, reportSpec,
064: dataSourceSpec, reportFilter);
065: case FilterDefinitionFilterTypeType.INCLUDES_TYPE:
066: return getIncludesExp(paramValues, mode, reportSpec,
067: dataSourceSpec, reportFilter);
068: case FilterDefinitionFilterTypeType.IN_TYPE:
069: return getInExp(paramValues, mode, reportSpec,
070: dataSourceSpec, reportFilter);
071: default:
072: return null;
073: }
074: }
075:
076: private Expression getInExp(Map paramValues, int mode,
077: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
078: ReportFilter reportFilter) throws InfoException {
079: ReportDimensionSpec dimensionSpec = reportSpec
080: .getDimensionFromName(reportFilter.getFilterSpec()
081: .getDimensionName());
082: Collection values = getValues(mode, dataSourceSpec,
083: dimensionSpec, paramValues.get(getParamKey("VALUES"))
084: .toString());
085: return new InExp(new VariableExp(getVariableName(mode,
086: reportSpec)), values);
087: }
088:
089: public Collection getValues(int mode, ReportDataSourceSpec data,
090: ReportDimensionSpec dimensionSpec, String s)
091: throws InfoException {
092: try {
093: return filterSpec.getValues(mode, data, dimensionSpec, s);
094: } catch (Exception e) {
095: throw new InfoException("85", e);
096: }
097: }
098:
099: /**
100: * Devuelve el nombre de la variable segun el modo que se la uitlizará
101: * @param mode Modo de uso
102: * @return
103: */
104: private Object getVariableName(int mode, ReportSpec reportSpec) {
105:
106: //ReportSourceDimension reportSourceDimension = reportSource.getDimensionfromName(getFilterDefinition().getDimensionName());
107:
108: ReportDimensionSpec dimensionSpec = reportSpec
109: .getDimensionFromName(getFilterSpec()
110: .getDimensionName());
111: switch (mode) {
112: case ReportFilterBuilder.VARMODE_INDEX:
113: return new Integer(dimensionSpec.getReportSourceIndex());
114: case ReportFilterBuilder.VARMODE_DATAINDEX:
115: return new Integer(dimensionSpec.getDataSourceIndex());
116: case ReportFilterBuilder.VARMODE_NAME:
117: return dimensionSpec.getName();
118: case ReportFilterBuilder.VARMODE_EXTERNALDATA:
119: return dimensionSpec.getExternalData();
120: }
121: return null;
122: }
123:
124: /**
125: * Devuelve el nombre del parámetro compuesto
126: * @param filterParam
127: * @return
128: */
129: private String getParamKey(String filterParam) {
130: return getFilterSpec().getName() + filterParam;
131: }
132:
133: /**
134: * Devuelve un IncludesExp a partir de los valores de los parámetros
135: * @param paramValues
136: * @param mode Modo de uso de parámetros
137: * @return
138: */
139: private Expression getIncludesExp(Map paramValues, int mode,
140: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
141: ReportFilter reportFilter) {
142: ReportDimensionSpec dimensionSpec = reportSpec
143: .getDimensionFromName(reportFilter.getFilterSpec()
144: .getDimensionName());
145: return new IncludesExp(new VariableExp(getVariableName(mode,
146: reportSpec)), new ConstantExp(ReportFilterBuilder
147: .getConstatValue(mode, paramValues
148: .get(getParamKey("VALUE")), dataSourceSpec,
149: dimensionSpec.getDataType().getType())));
150: }
151:
152: /**
153: * Devuelve un EndWithExp a partir de los valores de los parámetros
154: * @param paramValues
155: * @param mode Modo de uso de parámetros
156: * @return
157: */
158: private Expression getEndWithExp(Map paramValues, int mode,
159: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
160: ReportFilter reportFilter) {
161: ReportDimensionSpec dimensionSpec = reportSpec
162: .getDimensionFromName(reportFilter.getFilterSpec()
163: .getDimensionName());
164: return new EndsWithExp(new VariableExp(getVariableName(mode,
165: reportSpec)), new ConstantExp(ReportFilterBuilder
166: .getConstatValue(mode, paramValues
167: .get(getParamKey("VALUE")), dataSourceSpec,
168: dimensionSpec.getDataType().getType())));
169: }
170:
171: /**
172: * Devuelve un BeginWithExp a partir de los valores de los parámetros
173: * @param paramValues
174: * @param mode Modo de uso de parámetros
175: * @return
176: */
177:
178: private Expression getBeginWithExp(Map paramValues, int mode,
179: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
180: ReportFilter reportFilter) {
181: ReportDimensionSpec dimensionSpec = reportSpec
182: .getDimensionFromName(reportFilter.getFilterSpec()
183: .getDimensionName());
184: return new BeginsWithExp(new VariableExp(getVariableName(mode,
185: reportSpec)), new ConstantExp(ReportFilterBuilder
186: .getConstatValue(mode, paramValues
187: .get(getParamKey("VALUE")), dataSourceSpec,
188: dimensionSpec.getDataType().getType())));
189: }
190:
191: /**
192: * Devuelve un EqualToExp a partir de los valores de los parámetros
193: * @param paramValues
194: * @param mode Modo de uso de parámetros
195: * @return
196: */
197: private Expression getEqualToExp(Map paramValues, int mode,
198: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
199: ReportFilter reportFilter) {
200: ReportDimensionSpec dimensionSpec = reportSpec
201: .getDimensionFromName(reportFilter.getFilterSpec()
202: .getDimensionName());
203: return new EqualTo(new VariableExp(getVariableName(mode,
204: reportSpec)), new ConstantExp(ReportFilterBuilder
205: .getConstatValue(mode, paramValues
206: .get(getParamKey("VALUE")), dataSourceSpec,
207: dimensionSpec.getDataType().getType())));
208: }
209:
210: /**
211: * Devuelve un LessThanExp a partir de los valores de los parámetros
212: * @param paramValues
213: * @param mode Modo de uso de parámetros
214: * @return
215: */
216: private Expression getLessThanExp(Map paramValues, int mode,
217: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
218: ReportFilter reportFilter) {
219: ReportDimensionSpec dimensionSpec = reportSpec
220: .getDimensionFromName(reportFilter.getFilterSpec()
221: .getDimensionName());
222: return new LessThan(new VariableExp(getVariableName(mode,
223: reportSpec)), new ConstantExp(ReportFilterBuilder
224: .getConstatValue(mode, paramValues
225: .get(getParamKey("VALUE")), dataSourceSpec,
226: dimensionSpec.getDataType().getType())));
227: }
228:
229: /**
230: * Devuelve un GraterThanExp a partir de los valores de los parámetros
231: * @param paramValues
232: * @param mode Modo de uso de parámetros
233: * @return
234: */
235: private Expression getGraterThanExp(Map paramValues, int mode,
236: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
237: ReportFilter reportFilter) {
238: ReportDimensionSpec dimensionSpec = reportSpec
239: .getDimensionFromName(reportFilter.getFilterSpec()
240: .getDimensionName());
241: return new GreaterThan(new VariableExp(getVariableName(mode,
242: reportSpec)), new ConstantExp(ReportFilterBuilder
243: .getConstatValue(mode, paramValues
244: .get(getParamKey("VALUE")), dataSourceSpec,
245: dimensionSpec.getDataType().getType())));
246: }
247:
248: /**
249: * Devuelve un RangeExp a partir de los valores de los parámetros
250: * @param paramValues
251: * @param mode Modo de uso de parámetros
252: * @return
253: */
254: private Expression getRangeExp(Map paramValues, int mode,
255: ReportSpec reportSpec, ReportDataSourceSpec dataSourceSpec,
256: ReportFilter reportFilter) {
257: ReportDimensionSpec dimensionSpec = reportSpec
258: .getDimensionFromName(reportFilter.getFilterSpec()
259: .getDimensionName());
260: String fromKey = getParamKey("FROM");
261: Expression subexp1 = new VariableExp(getVariableName(mode,
262: reportSpec)).newGreaterOrEqualTo(new ConstantExp(
263: ReportFilterBuilder.getConstatValue(mode, paramValues
264: .get(fromKey), dataSourceSpec, dimensionSpec
265: .getDataType().getType())));
266: String toKey = getParamKey("TO");
267: Expression subexp2 = new VariableExp(getVariableName(mode,
268: reportSpec)).newLessOrEquealTo(new ConstantExp(
269: ReportFilterBuilder.getConstatValue(mode, paramValues
270: .get(toKey), dataSourceSpec, dimensionSpec
271: .getDataType().getType())));
272: return subexp1.newAnd(subexp2);
273: }
274: }
|