0001: package com.calipso.reportgenerator.common;
0002:
0003: import com.calipso.reportgenerator.reportcalculator.*;
0004: import com.calipso.reportgenerator.reportdefinitions.types.*;
0005: import com.calipso.reportgenerator.reportdefinitions.*;
0006: import com.calipso.reportgenerator.common.LanguageTraslator;
0007: import com.calipso.common.DateEx;
0008:
0009: import java.util.*;
0010: import java.text.MessageFormat;
0011: import java.io.Serializable;
0012:
0013: /** Esta clase contiene la información necesaria para ejecutar una consulta a sobre los datos, especificando las,
0014: * agrupaciones, filtros, campos visibles, ordenamiento, etc.
0015: */
0016: public class ReportQuery implements Serializable {
0017: private ReportSpec reportSpec;
0018: private List dimensions;
0019: private List metrics;
0020: private List accumulableMetrics;
0021: private Map paramValues;
0022: private List filterDefinitions;
0023: private Map dimensionFilterValues;
0024: private boolean visibleTotals;
0025: private EnumerationCubeFilter rankingFilter;
0026: private EnumerationCubeFilter excludeGroupFilter = null;
0027:
0028: /** Inicializa una nueva Consulta, asignandole a las dimensiones y a las métrcias las propiedades por defecto que se
0029: * obtienen de la definición de reporte
0030: * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
0031: * de las rows del DataSource.
0032: * @throws com.calipso.reportgenerator.common.InfoException
0033: */
0034: public ReportQuery(ReportSpec reportSpec) throws InfoException {
0035: this (reportSpec, true);
0036: }
0037:
0038: /**
0039: * Inicializa una nueva Consulta permitiendo especificar si se desea que a las dimensiones y las métricas se les asignen
0040: * las propiedades por defecto que se obtienen de la definición del reporte.
0041: * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
0042: * de las rows del DataSource.
0043: * @param defaultInitialize true = valores de propiedades por defecto segun definición de reporte. false = ninguna métrica
0044: * visible, ninguna dimension agrupa (Location = PAGE).
0045: */
0046: public ReportQuery(ReportSpec reportSpec, boolean defaultInitialize)
0047: throws InfoException {
0048: this .reportSpec = reportSpec;
0049: initialize(defaultInitialize);
0050: }
0051:
0052: /**
0053: * Inicializa la query y le aplica los valores del Report view indicado
0054: * @param reportSpec Contiene la información necesaria para ubicar los datos de las dimensiones y las métricas dentro
0055: * de las rows del DataSource.
0056: * @param reportView Continen los valores especificos para la vista solicitada
0057: */
0058: public ReportQuery(ReportSpec reportSpec, ReportView reportView)
0059: throws InfoException {
0060: this (reportSpec, true);
0061: overrideQuery(reportView);
0062: }
0063:
0064: /**
0065: * Sobreescribe los valores particulares de el report view
0066: * @param reportView
0067: */
0068: private void overrideQuery(ReportView reportView)
0069: throws InfoException {
0070: if (reportView != null) {
0071: overrideParamValues(reportView);
0072: overrideDimensionValues(reportView);
0073: overrideMetricsValues(reportView);
0074: overrideFiltersValues(reportView);
0075: generalOverride(reportView);
0076: }
0077: }
0078:
0079: private void overrideParamValues(ReportView reportView)
0080: throws InfoException {
0081: if (reportView.getViewParameterValues() != null) {
0082: Map overrideParams = getParamValuesFromView(reportView
0083: .getViewParameterValues(), getReportSpec());
0084: this .paramValues = ReportFilterBuilder.mergeParamValues(
0085: getParamValues(), overrideParams);
0086: }
0087: }
0088:
0089: public static Map getParamValuesFromView(
0090: ViewParameterValues viewParameters, ReportSpec reportSpec)
0091: throws InfoException {
0092: Map result = new HashMap();
0093: ViewParameterValue[] viewParameterValues = viewParameters
0094: .getViewParameterValue();
0095: for (int i = 0; i < viewParameterValues.length; i++) {
0096: //Aca!
0097: //Hacer que estoy view parametros todos string se transformen en parametros con tipos shared
0098: ViewParameterValue viewParameterValue = viewParameterValues[i];
0099: ReportFilterSpec filterSpec = reportSpec
0100: .getFilterSpecFromParamName(viewParameterValue
0101: .getViewParamName());
0102: int dataType;
0103: if (filterSpec.getDataType() != null) {
0104: dataType = filterSpec.getDataType().getType();
0105: } else {
0106: dataType = reportSpec.getDimensionFromName(
0107: filterSpec.getDimensionName()).getDataType()
0108: .getType();
0109: }
0110: Object value = SharedData.newFrom(dataType,
0111: viewParameterValue.getViewParamValue());
0112: result.put(viewParameterValue.getViewParamName(), value);
0113: }
0114: return result;
0115: }
0116:
0117: private void overrideFiltersValues(ReportView reportView)
0118: throws InfoException {
0119: DimensionProperties pr = reportView.getDimensionProperties();
0120: DimensionProperty[] properties = pr.getDimensionProperty();
0121: for (int i = 0; i < properties.length; i++) {
0122: Set set = new TreeSet();
0123: DimensionProperty property = properties[i];
0124: ReportDimensionSpec dimensionSpec = reportSpec
0125: .getDimensionFromName(property.getDimensionName());
0126: int dimensionIndex = dimensionSpec.getIndex();
0127: //int dimensionIndex = reportSpec.getDimensionFromName(property.getDimensionName()).getIndex();
0128: ExcludeValue[] values = property.getExcludeValue();
0129: for (int j = 0; j < values.length; j++) {
0130: ExcludeValue value = values[j];
0131: switch (dimensionSpec.getDataType().getType()) {
0132: case ReportDataType.STRING_TYPE:
0133: set.add(value.getValue());
0134: break;
0135: case ReportDataType.DATETIME_TYPE:
0136: case ReportDataType.DATE_TYPE:
0137: try {
0138: set.add(SharedDate.newFrom(new DateEx(value
0139: .getValue())));
0140: } catch (InfoException e) {
0141: throw new InfoException(LanguageTraslator
0142: .traslate("262")
0143: + value.getValue(), e);
0144: }
0145: break;
0146: case ReportDataType.FLOAT_TYPE:
0147: set.add(SharedFloat.newFrom(new Float(value
0148: .getValue())));
0149: break;
0150: case ReportDataType.INTEGER_TYPE:
0151: set.add(SharedInteger.newFrom(new Integer(value
0152: .getValue())));
0153: break;
0154: case ReportDataType.BOOLEAN_TYPE:
0155: set.add(Boolean.valueOf(value.getValue()));
0156: break;
0157: }
0158: }
0159: getDimensionFilterValues().put(new Integer(dimensionIndex),
0160: set);
0161: }
0162: }
0163:
0164: /**
0165: * Sobreescrie los parámetros generales de la query
0166: * @param reportView
0167: */
0168: private void generalOverride(ReportView reportView) {
0169: this .visibleTotals = reportView.getVisibleTotals();
0170: }
0171:
0172: /**
0173: * Sobrescribe los valores la las metricas del reportview
0174: * @param reportView
0175: * @throws com.calipso.reportgenerator.common.InfoException
0176: */
0177: private void overrideMetricsValues(ReportView reportView)
0178: throws InfoException {
0179: if (reportView.getMetricProperties() != null) {
0180: int count = reportView.getMetricProperties()
0181: .getMetricPropertyCount();
0182: MetricProperty metricProperty;
0183: for (int i = 0; i < count; i++) {
0184: metricProperty = reportView.getMetricProperties()
0185: .getMetricProperty()[i];
0186: setMetricProperties(metricProperty.getMetricName(),
0187: metricProperty.getVisible(), i);
0188: }
0189: }
0190: }
0191:
0192: /**
0193: * Asigna los valores
0194: * @param reportView
0195: * @throws com.calipso.reportgenerator.common.InfoException
0196: */
0197: private void overrideDimensionValues(ReportView reportView)
0198: throws InfoException {
0199: int count = reportView.getDimensionProperties()
0200: .getDimensionPropertyCount();
0201: DimensionProperty dimensionProperty;
0202: for (int i = 0; i < count; i++) {
0203: dimensionProperty = reportView.getDimensionProperties()
0204: .getDimensionProperty()[i];
0205: setDimensionProperties(
0206: dimensionProperty.getDimensionName(),
0207: getLocationTypeFormView(dimensionProperty
0208: .getLocation()),
0209: getOrderTypeFormView(dimensionProperty.getOrder()),
0210: dimensionProperty.getUbication(), dimensionProperty
0211: .getRankMetricName());
0212: }
0213: }
0214:
0215: /**
0216: * Convierte los location de los properties del view al los del dimension definition
0217: * @param locationType
0218: * @return
0219: */
0220: private DimensionDefinitionLocationType getLocationTypeFormView(
0221: DimensionPropertyLocationType locationType) {
0222: return DimensionDefinitionLocationType.valueOf(locationType
0223: .toString());
0224: }
0225:
0226: /**
0227: * Convierte los order de los properties del view al los del dimension definition
0228: * @param orderType
0229: * @return
0230: */
0231: private DimensionDefinitionOrderType getOrderTypeFormView(
0232: DimensionPropertyOrderType orderType) {
0233: return DimensionDefinitionOrderType.valueOf(orderType
0234: .toString());
0235: }
0236:
0237: /**
0238: * Ejecuta la inicialización
0239: * @param defaultInitialize
0240: */
0241: private void initialize(boolean defaultInitialize) {
0242: this .dimensions = new ArrayList();
0243: this .metrics = new ArrayList();
0244: this .accumulableMetrics = new ArrayList();
0245: this .visibleTotals = getReportSpec().isVisibleTotals();
0246: DimensionDefinitionLocationType location;
0247: Collection dimensions;
0248:
0249: if ((getReportSpec().getReportType().getType() == ReportDefinitionReportTypeType.CUBE_TYPE)
0250: || (getReportSpec().getReportType().getType() == ReportDefinitionReportTypeType.CHARTCUBE_TYPE)) {
0251: if (defaultInitialize) {
0252: location = DimensionDefinitionLocationType.ROW;
0253: dimensions = getReportSpec().getDimensionsByLocation(
0254: location);
0255: addDimensionsByLocation(dimensions, location);
0256: location = DimensionDefinitionLocationType.COLUMN;
0257: dimensions = getReportSpec().getDimensionsByLocation(
0258: location);
0259: addDimensionsByLocation(dimensions, location);
0260: location = DimensionDefinitionLocationType.PAGE;
0261: dimensions = getReportSpec().getDimensionsByLocation(
0262: location);
0263: addDimensionsByLocation(dimensions, location);
0264: } else {
0265: dimensions = getReportSpec().getDimensionSpecs()
0266: .values();
0267: addDimensionsByLocation(dimensions,
0268: DimensionDefinitionLocationType.PAGE);
0269: }
0270: } else {
0271: dimensions = getReportSpec().getDimensionsByGrouping(true);
0272: addDimensionsByGrouping(dimensions, true);
0273: dimensions = getReportSpec().getDimensionsByGrouping(false);
0274: addDimensionsByGrouping(dimensions, false);
0275: }
0276:
0277: Collection metrics = getReportSpec().getMetricsByIndex();
0278: for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
0279: ReportMetricSpec metricSpec = (ReportMetricSpec) iterator
0280: .next();
0281: int index = metricSpec.getReportSourceIndex();
0282: boolean visible;
0283: if (defaultInitialize) {
0284: visible = metricSpec.getVisible();
0285: } else {
0286: visible = false;
0287: }
0288: getMetrics().add(
0289: new QueryMetric(metricSpec.getName(), index,
0290: visible, getMetrics().size(), metricSpec
0291: .getAccumulable()));
0292: }
0293:
0294: Collection accmetrics = getReportSpec()
0295: .getAccumulableMetricsByIndex();
0296: for (Iterator iterator = accmetrics.iterator(); iterator
0297: .hasNext();) {
0298: ReportMetricSpec metricSpec = (ReportMetricSpec) iterator
0299: .next();
0300: int index = metricSpec.getReportSourceIndex();
0301: boolean visible;
0302: if (defaultInitialize) {
0303: visible = metricSpec.getVisible();
0304: } else {
0305: visible = false;
0306: }
0307: getAccumulableMetrics().add(
0308: new QueryMetric(metricSpec.getName(), index,
0309: visible, getMetrics().size(), metricSpec
0310: .getAccumulable()));
0311: }
0312: }
0313:
0314: /**
0315: * Inicializa los QueryDimension que representan a los ReportDimensionSpec que se reciben como parámetro, segun la
0316: * ubicación de agrupación (para reportes tipo cubo)
0317: * @param dimensions
0318: * @param location
0319: */
0320:
0321: private void addDimensionsByLocation(Collection dimensions,
0322: DimensionDefinitionLocationType location) {
0323: Iterator iter = dimensions.iterator();
0324: int locationOrder = 0;
0325: while (iter.hasNext()) {
0326: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter
0327: .next();
0328: if (dimensionSpec.getInReportDefinition()) {
0329: getDimensions().add(
0330: new QueryDimension(dimensionSpec.getName(),
0331: dimensionSpec.getReportSourceIndex(),
0332: location, dimensionSpec.getOrder(),
0333: locationOrder, false, dimensionSpec
0334: .getRankMetricName()));
0335: locationOrder++;
0336: }
0337: }
0338: }
0339:
0340: /**
0341: * Inicializa los QueryDimension que representan a los ReportDimensionSpec que se reciben como parámetro, segun la
0342: * rol de agrupación (para reportes estáticos)
0343: * @param dimensions
0344: * @param groups
0345: */
0346: private void addDimensionsByGrouping(Collection dimensions,
0347: boolean groups) {
0348: Iterator iter = dimensions.iterator();
0349: int locationOrder = 0;
0350: while (iter.hasNext()) {
0351: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter
0352: .next();
0353: if (dimensionSpec.getInReportDefinition()) {
0354: getDimensions().add(
0355: new QueryDimension(dimensionSpec.getName(),
0356: dimensionSpec.getReportSourceIndex(),
0357: DimensionDefinitionLocationType.PAGE,
0358: dimensionSpec.getOrder(),
0359: locationOrder, groups, dimensionSpec
0360: .getRankMetricName()));
0361: locationOrder++;
0362: }
0363: }
0364: }
0365:
0366: /**
0367: * Devuelve la query traducida a la forma que utiliza el módulo de cálculo de cubos.
0368: * @return
0369: * @throws com.calipso.reportgenerator.common.InfoException
0370: */
0371: public CubeQuery getCubeQuery() throws InfoException {
0372: try {
0373: CubeQuery query = new CubeQuery();
0374: int[] rows = getCubeRowFields();
0375: int[] cols = getCubeColumnFields();
0376: int[] pages = getCubePageFields();
0377: int[] metrics = getCubeMetricFields();
0378: boolean[] ascending = getDimensionOrder();
0379: int[] dimensioRank = getDimensionRank();
0380: query.setRows(rows);
0381: query.setColumns(cols);
0382: query.setPages(pages);
0383: query.setMetrics(metrics);
0384: query.setAscending(ascending);
0385: query.setDimensionRank(dimensioRank);
0386: query.setFilter(getCubeFilter(getParamValues()));
0387: query.setRankingFilter(getRankingFilter());
0388: query.setEnumFilter(getEnumFilter());
0389: query.setExcludeGroupFilter(excludeGroupFilter);
0390: return query;
0391: } catch (Exception e) {
0392: throw new InfoException(LanguageTraslator.traslate("82"), e);
0393: }
0394: }
0395:
0396: /** Devuelve una lista que contiene las métricas visibles
0397: * @return
0398: */
0399: public List getVisibleMetrics() {
0400: List list = new ArrayList();
0401: for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
0402: QueryMetric queryMetric = (QueryMetric) iterator.next();
0403: if (queryMetric.getVisible()) {
0404: list.add(queryMetric);
0405: }
0406: }
0407: return list;
0408: }
0409:
0410: /** Devuelve una lista que contiene las métricas acumulables visibles
0411: * @return
0412: */
0413: public List getVisibleAccumulableMetrics() {
0414: List list = new ArrayList();
0415: for (Iterator iterator = accumulableMetrics.iterator(); iterator
0416: .hasNext();) {
0417: QueryMetric queryMetric = (QueryMetric) iterator.next();
0418: if (queryMetric.getVisible()) {
0419: list.add(queryMetric);
0420: }
0421: }
0422: return list;
0423: }
0424:
0425: /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
0426: * @return
0427: */
0428: private int[] getCubeMetricFields() {
0429: List list = getMetrics();
0430: int[] array = new int[list.size()];
0431: int index = 0;
0432: for (Iterator iterator = list.iterator(); iterator.hasNext();) {
0433: QueryMetric queryMetric = (QueryMetric) iterator.next();
0434: array[index] = queryMetric.getIndex();
0435: index++;
0436: }
0437: return array;
0438: }
0439:
0440: /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
0441: * acumulables
0442: * @return
0443: */
0444:
0445: private int[] getStaticAccumulableMetricFields() {
0446: List list = getAccumulableMetrics();
0447: int[] array = new int[list.size()];
0448: int index = 0;
0449: for (Iterator iterator = list.iterator(); iterator.hasNext();) {
0450: QueryMetric queryMetric = (QueryMetric) iterator.next();
0451: array[index] = queryMetric.getIndex();
0452: index++;
0453: }
0454: return array;
0455: }
0456:
0457: /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las métricas
0458: * visibles
0459: * @return
0460: */
0461:
0462: public int[] getCubeVisibleMetricFields() {
0463: List list = getVisibleMetrics();
0464: int[] array = new int[list.size()];
0465: int index = 0;
0466: for (Iterator iterator = list.iterator(); iterator.hasNext();) {
0467: QueryMetric queryMetric = (QueryMetric) iterator.next();
0468: array[index] = queryMetric.getIndex();
0469: index++;
0470: }
0471: return array;
0472: }
0473:
0474: /** Devuelve un array de boolean que contiene el tipo de ordenamiento para cada dimension
0475: * true = Ascendente
0476: * false = Descendente
0477: *
0478: * @return
0479: */
0480: private boolean[] getDimensionOrder() {
0481: int size = getReportSpec().getDimensionSpecs().size();
0482: boolean[] orders = new boolean[size];
0483: for (int i = 0; i < getDimensions().size(); i++) {
0484: QueryDimension queryDimension = (QueryDimension) getDimensions()
0485: .get(i);
0486: orders[queryDimension.getIndex()] = queryDimension
0487: .getOrder().getType() == (DimensionDefinitionOrderType.A
0488: .getType());
0489: }
0490: return orders;
0491: }
0492:
0493: /**
0494: * Devuelve un array que contiene los indices de las métricas que se utilizaran para ranking (ordenamiento por valor
0495: * de métrica) para cada dimensión. Si no se utiliza ranking el valor es -1, ordenando por valor de dimensión.
0496: */
0497: private int[] getDimensionRank() {
0498: int size = getReportSpec().getDimensionSpecs().size();
0499: int[] dimensionRank = new int[size];
0500: for (int i = 0; i < getDimensions().size(); i++) {
0501: QueryDimension queryDimension = (QueryDimension) getDimensions()
0502: .get(i);
0503: ReportMetricSpec metricSpec = null;
0504: if (queryDimension.getRankMetricName() != null) {
0505: metricSpec = getReportSpec().getMetricFromName(
0506: queryDimension.getRankMetricName());
0507: }
0508: int metricIndex;
0509: if (metricSpec == null) {
0510: metricIndex = -1;
0511: } else {
0512: metricIndex = metricSpec.getReportSourceIndex();
0513: }
0514: dimensionRank[queryDimension.getIndex()] = metricIndex;
0515: }
0516: return dimensionRank;
0517: }
0518:
0519: /** Devuelve un array de enteros que representan a los indices de la row donde se encuentran los valores de las dimensiones
0520: * segun las lista de dimensiones que recibe como parámetro
0521: * Se utliza para resolver <code>getCubeRowFields()</code> y <code>getCubeColumnFields()</code>
0522: * @param dimensions
0523: * @return
0524: */
0525: private int[] getDimensionIndexArray(List dimensions) {
0526: int size = dimensions.size();
0527: int[] array = new int[size];
0528: for (int i = 0; i < size; i++) {
0529: QueryDimension queryDimension = (QueryDimension) dimensions
0530: .get(i);
0531: array[i] = queryDimension.getIndex();
0532: }
0533: return array;
0534: }
0535:
0536: /** Devuleve los indices de las dimensions que agrupan por fila
0537: *
0538: * @return
0539: */
0540: private int[] getCubeRowFields() {
0541: return getDimensionIndexArray(getRowDimensions());
0542: }
0543:
0544: /** Devuelve los indices de las dimensiones que agrupan por columna
0545: *
0546: * @return
0547: */
0548: private int[] getCubeColumnFields() {
0549: return getDimensionIndexArray(getColumnDimensions());
0550: }
0551:
0552: /** Devuelve los indices de las dimensiones que agrupan por página
0553: *
0554: * @return
0555: */
0556:
0557: private int[] getCubePageFields() {
0558: return getDimensionIndexArray(getPageDimensions());
0559: }
0560:
0561: /**
0562: * Lista que contiene todas las dimensiones involucradas en la query
0563: * @return
0564: */
0565:
0566: public List getDimensions() {
0567: return dimensions;
0568: }
0569:
0570: /** Devuelve una lista con todas las dimensiones que agrupan según el parámetro <code>location</code>.
0571: *
0572: * @param location ubicación de las dimensiones que se desea obtener.
0573: * @return
0574: */
0575: public List getDimensionsByLocation(
0576: DimensionDefinitionLocationType location) {
0577:
0578: List list = new ArrayList();
0579:
0580: for (Iterator iterator = getDimensions().iterator(); iterator
0581: .hasNext();) {
0582: QueryDimension queryDimension = (QueryDimension) iterator
0583: .next();
0584: if (queryDimension.getLocation().getType() == location
0585: .getType()) {
0586: (list).add(queryDimension);
0587: }
0588: }
0589: Collections.sort(list, new Comparator() {
0590: public int compare(Object o1, Object o2) {
0591: QueryDimension dim1 = (QueryDimension) o1;
0592: QueryDimension dim2 = (QueryDimension) o2;
0593: return dim1.getLocationOrder()
0594: - dim2.getLocationOrder();
0595: }
0596: });
0597: return list;
0598: }
0599:
0600: /**
0601: * Lista que contiene todas las dimensiones que agrupan por fila
0602: * @return
0603: */
0604: public List getRowDimensions() {
0605: return getDimensionsByLocation(DimensionDefinitionLocationType.ROW);
0606: }
0607:
0608: /**
0609: * Lista que contiene todas las dimensiones que agrupan por columna
0610: * @return
0611: */
0612: public List getColumnDimensions() {
0613: return getDimensionsByLocation(DimensionDefinitionLocationType.COLUMN);
0614: }
0615:
0616: /**
0617: * Lista que contiene todas las dimensiones que estan disponibles para agrupar
0618: * @return
0619: */
0620: public List getPageDimensions() {
0621: return getDimensionsByLocation(DimensionDefinitionLocationType.PAGE);
0622: }
0623:
0624: /**
0625: * Lista que contiene todos las métricas que el usuario puede activar (ver)
0626: * @return
0627: */
0628: public List getMetrics() {
0629: return metrics;
0630: }
0631:
0632: /**
0633: * Lista que contiene todos las métricas acumulables que el usuario puede activar (ver)
0634: * @return
0635: */
0636: public List getAccumulableMetrics() {
0637: return accumulableMetrics;
0638: }
0639:
0640: /**
0641: * Devuelve la estructura <code>ReportSpec</code> que sirve para obtener los indices de las dimensiones y las métricas en
0642: * la matriz que se llenó a partir de <code>DataSource</code>
0643: * @return
0644: */
0645:
0646: public ReportSpec getReportSpec() {
0647: return reportSpec;
0648: }
0649:
0650: /**
0651: * Hace que todas las dimensiones no intervengan en la agrupación (ni por ROW ni por COLUMN)
0652: * Inicializa los criterios de ordenamiento de los valores de dimensión en A (ascendente)
0653: * Asigna -1 al orden relativo de las dimensiones
0654: * Este método se utiliza para configurar una nueva query a partir de una query existente, la query
0655: * que se obtiene por defecto está inicializada con los valores prefijados en el ReportSourceDefinition
0656: */
0657: public void clearQuery() {
0658: for (int i = 0; i < getDimensions().size(); i++) {
0659: QueryDimension queryDimension = (QueryDimension) getDimensions()
0660: .get(i);
0661: queryDimension.setProperties(
0662: DimensionDefinitionLocationType.PAGE,
0663: DimensionDefinitionOrderType.A, 1, "");
0664: }
0665: for (int i = 0; i < getMetrics().size(); i++) {
0666: QueryMetric queryMetric = (QueryMetric) getMetrics().get(i);
0667: queryMetric.setVisible(false);
0668: }
0669: paramValues = null;
0670: dimensionFilterValues = null;
0671: }
0672:
0673: /**
0674: * Especifica la ubicación de agrupación de una dimensión
0675: * @param name
0676: * @param location
0677: * @throws com.calipso.reportgenerator.common.InfoException
0678: */
0679:
0680: public void setDimensionLocation(String name,
0681: DimensionDefinitionLocationType location)
0682: throws InfoException {
0683: QueryDimension queryDimension = getQueryDimensionFromName(name);
0684: queryDimension.setLocation(location);
0685: }
0686:
0687: /**
0688: * Especifica el criterio de ordenamiento de los valores de una dimensión
0689: * @param name
0690: * @param order
0691: * @throws com.calipso.reportgenerator.common.InfoException
0692: */
0693: public void setDimensionOrder(String name,
0694: DimensionDefinitionOrderType order) throws InfoException {
0695: QueryDimension queryDimension = getQueryDimensionFromName(name);
0696: queryDimension.setOrder(order);
0697: }
0698:
0699: /**
0700: * Especifica el posición de la dimensión relativa a la localización
0701: * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
0702: * @param name
0703: * @param order
0704: * @throws com.calipso.reportgenerator.common.InfoException
0705: */
0706: public void setDimensionLocationOrder(String name, int order)
0707: throws InfoException {
0708: QueryDimension queryDimension = getQueryDimensionFromName(name);
0709: queryDimension.setLocationOrder(order);
0710:
0711: }
0712:
0713: /**
0714: * Especifica el posición de la dimensión relativa a la localización, si el parámetro updateOrders es True, se reacomodan
0715: * los ordenes desde la dimensión especificada en adelante
0716: * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
0717: * @param name
0718: * @param order
0719: * @throws com.calipso.reportgenerator.common.InfoException
0720: */
0721: public void setDimensionLocationOrder(String name, int order,
0722: boolean updateOrders) throws InfoException {
0723: setDimensionLocationOrder(name, order);
0724: if (updateOrders) {
0725: locationOrderUpdated(name, order);
0726: }
0727: }
0728:
0729: /**
0730: * Reacomoda el orden de las dimensiones cuando cambia el orden
0731: * @param name
0732: * @param locationOrder
0733: */
0734: private void locationOrderUpdated(String name, int locationOrder)
0735: throws InfoException {
0736: QueryDimension dimension = getQueryDimensionFromName(name);
0737: List list = getDimensionsByLocation(dimension.getLocation());
0738: for (Iterator iterator = list.iterator(); iterator.hasNext();) {
0739: QueryDimension queryDimension = (QueryDimension) iterator
0740: .next();
0741: if (name != queryDimension.getName()
0742: && queryDimension.getLocationOrder() >= locationOrder) {
0743: queryDimension.setLocationOrder(queryDimension
0744: .getLocationOrder() + 1);
0745: }
0746: }
0747: }
0748:
0749: /**
0750: * Especifica todas las propiedades de la dimension que afectan la query
0751: *
0752: * @param name
0753: * @param location ubicación de agrupación (pueder ser null, en ese caso conserva el valor anterior)
0754: * @param order criterio de ordenamiento (pueder ser null, en ese caso conserva el valor anterior)
0755: * @param locationOrder posición relativa a la localización (para conservar la posición anterior se debe pasar valor -1)
0756: * @param rankMetricName
0757: * @throws com.calipso.reportgenerator.common.InfoException
0758: */
0759: public void setDimensionProperties(String name,
0760: DimensionDefinitionLocationType location,
0761: DimensionDefinitionOrderType order, int locationOrder,
0762: String rankMetricName) throws InfoException {
0763: QueryDimension queryDimension = getQueryDimensionFromName(name);
0764: queryDimension.setProperties(location, order, locationOrder,
0765: rankMetricName);
0766: if (locationOrder >= 0) {
0767: // locationOrderUpdated(name, locationOrder);
0768: }
0769: }
0770:
0771: /**
0772: * Especifica el nombre de la métrica por la que se desea ejecutar el ranking
0773: * @param name
0774: * @param rankMetricName
0775: * @throws com.calipso.reportgenerator.common.InfoException
0776: */
0777: public void setDimensionRankMetricName(String name,
0778: String rankMetricName) throws InfoException {
0779: QueryDimension queryDimension = getQueryDimensionFromName(name);
0780: queryDimension.setRankMetricName(rankMetricName);
0781: }
0782:
0783: /**
0784: * Especifica si se desea que los valores de la métrica estén visibles en el resultado de la query
0785: * @param name
0786: * @param visible
0787: * @throws com.calipso.reportgenerator.common.InfoException
0788: */
0789: public void setMetricVisible(String name, boolean visible)
0790: throws InfoException {
0791: QueryMetric queryMetric = getQueryMetricFromName(name);
0792: queryMetric.setVisible(visible);
0793: }
0794:
0795: /**
0796: * Especifica en que posición relativa a las métricas se ubica la métrica del nombre especificado.
0797: * El valor de <code>order</code> solo sirve para ordenar (comparar), no es obligatorio especificar números correlativos
0798: * @param name
0799: * @param order
0800: * @throws com.calipso.reportgenerator.common.InfoException
0801: */
0802: public void setMetricOrder(String name, int order)
0803: throws InfoException {
0804: QueryMetric queryMetric = getQueryMetricFromName(name);
0805: queryMetric.setMetricOrder(order);
0806: if (order <= 0) {
0807: metricOrderUpdated(name, order);
0808: }
0809: }
0810:
0811: /**
0812: * Reacomoda las métricas cuando cambia el orden
0813: * @param name
0814: * @param order
0815: */
0816:
0817: private void metricOrderUpdated(String name, int order) {
0818: for (Iterator iterator = metrics.iterator(); iterator.hasNext();) {
0819: QueryMetric queryMetric = (QueryMetric) iterator.next();
0820: if (name != queryMetric.getName()
0821: && queryMetric.getMetricOrder() >= order) {
0822: queryMetric
0823: .setMetricOrder(queryMetric.getMetricOrder() + 1);
0824: }
0825: }
0826: }
0827:
0828: /**
0829: * Especifica todas las propiedades de la métrica que afectan a la query
0830: * @param name
0831: * @param visible para mostrar u ocultar los valores de la métrica
0832: * @param order posición relativa a las métricas (si se quiere conservar el valor anterior parar el valor -1)
0833: * @throws com.calipso.reportgenerator.common.InfoException
0834: */
0835: public void setMetricProperties(String name, boolean visible,
0836: int order) throws InfoException {
0837: QueryMetric queryMetric = getQueryMetricFromName(name);
0838: queryMetric.setMetricProperties(visible, order);
0839: if (order <= 0) {
0840: metricOrderUpdated(name, order);
0841: }
0842: }
0843:
0844: /**
0845: * Devuelve una métrica(<code>QueryMetric</code>) a partir de su nombre
0846: * @param name
0847: * @return
0848: * @throws com.calipso.reportgenerator.common.InfoException
0849: */
0850: public QueryMetric getQueryMetricFromName(String name)
0851: throws InfoException {
0852: for (int i = 0; i < getMetrics().size(); i++) {
0853: QueryMetric queryMetric = (QueryMetric) getMetrics().get(i);
0854: if (queryMetric.getName().equalsIgnoreCase(name)) {
0855: return queryMetric;
0856: }
0857: }
0858: throw new InfoException(MessageFormat.format(LanguageTraslator
0859: .traslate("83"), new Object[] { name }));
0860: }
0861:
0862: /**
0863: * Devuelve una dimensión (<code>QueryDimension</code>) a partir de su nombre
0864: * @param name
0865: * @return
0866: * @throws com.calipso.reportgenerator.common.InfoException
0867: */
0868: public QueryDimension getQueryDimensionFromName(String name)
0869: throws InfoException {
0870: for (int i = 0; i < getDimensions().size(); i++) {
0871: QueryDimension queryDimension = (QueryDimension) getDimensions()
0872: .get(i);
0873: if (queryDimension.getName().equalsIgnoreCase(name)) {
0874: return queryDimension;
0875: }
0876: }
0877: throw new InfoException(MessageFormat.format(LanguageTraslator
0878: .traslate("84"), new Object[] { name }));
0879: }
0880:
0881: /**
0882: * Se utiliza para verificar si las propiedades asignadas a las dimensiones y a las métricas determinan una query válida
0883: * @return
0884: */
0885: public boolean isValid() {
0886: return getVisibleMetrics().size() > 0;
0887: }
0888:
0889: /** Devuelve los valores de parámetros especificados en la query, este método solo debería ser llamado desde la clase
0890: * <Code>Report</Code> para la ejecución de la query, para especificar u obtener los valores de los parámetros de la
0891: * query se deben utilizar los métodos <Code>getParamValue</Code> y <Code>setParamValue</Code>
0892: * @return
0893: */
0894: public Map getParamValues() {
0895: if (paramValues == null) {
0896: paramValues = initializeParamValues();
0897: }
0898: return paramValues;
0899: }
0900:
0901: private Map initializeParamValues() {
0902: return ReportFilterBuilder.mergeParamValues(null,
0903: getReportSpec().getParamValues(false));
0904: }
0905:
0906: /** Devuelve el valor un parámetro
0907: * @param key identificador del parámetro (nombre del filtro + nombre del parámetro)
0908: * @return valor del parámetro
0909: */
0910:
0911: public Object getParamValue(String key) {
0912: return getParamValues().get(key);
0913: }
0914:
0915: /** Devuelve el valor un parámetro
0916: *
0917: * @param filterName
0918: * @param parameterName
0919: * @return
0920: */
0921: public Object getParamValue(String filterName, String parameterName) {
0922: return getParamValue(filterName, parameterName);
0923: }
0924:
0925: /** Especifica el valor de un parámetro
0926: *
0927: * @param key identificador del parámetro
0928: * @param value valor del parámetro
0929: */
0930: public void setParamValue(String key, Object value) {
0931: getParamValues().put(key, value);
0932: }
0933:
0934: /** Especifica el valor de un parámetro
0935: *
0936: * @param filterName
0937: * @param parameterName
0938: * @param value
0939: */
0940: public void setParamValue(String filterName, String parameterName,
0941: Object value) {
0942: getParamValues().put(filterName + parameterName, value);
0943: }
0944:
0945: /**
0946: * Especifica los valores de varios parámetros contenidos en <code>paramValues</code> que es un <code>Map</code>
0947: * donde cada clave es el identificador de un parámetro y cada objeto asociado es el valor de un parámetro
0948: * @param paramValues
0949: */
0950: public void setParamValues(Map paramValues) {
0951: Iterator keys = paramValues.keySet().iterator();
0952: while (keys.hasNext()) {
0953: String key = (String) keys.next();
0954: setParamValue(key, paramValues.get(key));
0955: }
0956: }
0957:
0958: /**
0959: * devuelve un array que contiene
0960: * @return
0961: */
0962: public int[] getGroupingDimensionsIndexArray() {
0963: int[] groupingDimensions;
0964: int[] rows = getCubeRowFields();
0965: int[] cols = getCubeColumnFields();
0966:
0967: int rowsLenght;
0968: int columnsLenght;
0969: int dimensionsLenght;
0970: int index;
0971:
0972: rowsLenght = rows.length;
0973: columnsLenght = cols.length;
0974: dimensionsLenght = rowsLenght + columnsLenght;
0975: groupingDimensions = new int[dimensionsLenght];
0976: for (index = 0; index < rowsLenght; ++index) {
0977: groupingDimensions[index] = rows[index];
0978: }
0979: for (index = 0; index < columnsLenght; ++index) {
0980: groupingDimensions[index + rowsLenght] = cols[index];
0981: }
0982: return groupingDimensions;
0983: }
0984:
0985: /**
0986: * Construye un filtro de valores enumerados a excluir
0987: * @return
0988: */
0989: public EnumerationCubeFilter getEnumFilter() {
0990: EnumerationCubeFilter filter = EnumerationCubeFilter
0991: .excluding();
0992: Iterator iterator = getDimensionFilterValues().entrySet()
0993: .iterator();
0994: while (iterator.hasNext()) {
0995: Map.Entry entry = (Map.Entry) iterator.next();
0996: filter.addTo((Set) entry.getValue(), ((Integer) entry
0997: .getKey()).intValue());
0998: }
0999: return filter;
1000: }
1001:
1002: /**
1003: * Construye un filtro (post-filtro) a partir de las definiciones de filtro de la definición de reporte y los valores
1004: * de los parámetros enviados por el usuario
1005: * @param params
1006: * @return
1007: */
1008: protected ExpressionCubeFilter getCubeFilter(Map params)
1009: throws InfoException {
1010: try {
1011: ReportFilterBuilder filterBuilder = new ReportFilterBuilder(
1012: getFilterDefinitions(), params,
1013: ReportFilterBuilder.VARMODE_INDEX);
1014: return filterBuilder.getCubeFilter(getReportSpec(), null);
1015: } catch (Exception e) {
1016: throw new InfoException(LanguageTraslator.traslate("85"), e);
1017: }
1018: }
1019:
1020: /**
1021: * Devuelve las definiciones de filtros de la definición del Reporte
1022: * @return
1023: * @throws com.calipso.reportgenerator.common.InfoException
1024: */
1025: protected List getFilterDefinitions() throws InfoException {
1026: if (filterDefinitions == null) {
1027: filterDefinitions = new ArrayList();
1028: Collection filterSpecs = getReportSpec().getFilterSpecs();
1029: ReportFilter maxRowsFilter = getMaxRowsFilter();
1030: if (maxRowsFilter != null) {
1031: filterDefinitions.add(maxRowsFilter);
1032: }
1033: for (Iterator iterator = filterSpecs.iterator(); iterator
1034: .hasNext();) {
1035: ReportFilterSpec reportFilterSpec = (ReportFilterSpec) iterator
1036: .next();
1037: ReportFilter reportFilter = new ReportFilter(
1038: reportFilterSpec);
1039: filterDefinitions.add(reportFilter);
1040: }
1041: }
1042: return filterDefinitions;
1043: }
1044:
1045: /**
1046: * Devuelve el filtro para recuperar la información de la matriz por lotes de una cantidad fija
1047: * @return
1048: */
1049: private ReportFilter getMaxRowsFilter() {
1050: ReportFilter maxRowsFilter = null;
1051: ReportFilterSpec maxRowsFilterSpec = getReportSpec()
1052: .getMaxRowsFilterSpec();
1053: if (maxRowsFilterSpec != null) {
1054: maxRowsFilter = new ReportFilter(maxRowsFilterSpec);
1055: }
1056: return maxRowsFilter;
1057: }
1058:
1059: /**
1060: * Deveulve los valores de una dimension excluidos para el filtro enumerado
1061: * @return
1062: */
1063: protected Map getDimensionFilterValues() {
1064: if (dimensionFilterValues == null) {
1065: dimensionFilterValues = new HashMap();
1066: }
1067: return dimensionFilterValues;
1068: }
1069:
1070: /**
1071: * Devuelve la query traducida a la forma que utiliza el módulo de cálculo de reportes estáticos.
1072: * @return
1073: * @throws com.calipso.reportgenerator.common.InfoException
1074: */
1075: public StaticQuery getStaticQuery() throws InfoException {
1076: try {
1077: StaticQuery query = new StaticQuery();
1078: int[] group = getStaticGroupingDimensions();
1079: int[] noGroup = getStaticNonGroupingDimensions();
1080: int[] metrics = getCubeMetricFields();
1081: int[] accumulableMetrics = getStaticAccumulableMetricFields();
1082: boolean[] ascending = getDimensionOrder();
1083: query.setFilter(getCubeFilter(getParamValues()));
1084: query.setGroupDimensions(group);
1085: query.setNoGroupDimensions(noGroup);
1086: query.setMetrics(metrics);
1087: query.setAccumulableMetrics(accumulableMetrics);
1088: query.setAscending(ascending);
1089: query.setRankingFilter(getRankingFilter());
1090:
1091: // query.setFilter(getCubeFilter(getParamValues()));
1092: return query;
1093: } catch (Exception e) {
1094: throw new InfoException(LanguageTraslator.traslate("86"), e);
1095: }
1096: }
1097:
1098: /**
1099: * Devuelve los indices de las dimensiones que No agrupan
1100: * @return
1101: */
1102: private int[] getStaticNonGroupingDimensions() {
1103: return getDimensionIndexArray(getDimensionsByGrouping(false));
1104: }
1105:
1106: /**
1107: * Devuelve los indices de las dimensiones que agrupan
1108: */
1109:
1110: private int[] getStaticGroupingDimensions() {
1111: return getDimensionIndexArray(getDimensionsByGrouping(true));
1112: }
1113:
1114: /**
1115: * Deveulve una lista con las dimensiones segun su rol en la agrupación
1116: * @param groups
1117: * @return
1118: */
1119:
1120: private List getDimensionsByGrouping(boolean groups) {
1121:
1122: List list = new ArrayList();
1123: for (Iterator iterator = getDimensions().iterator(); iterator
1124: .hasNext();) {
1125: QueryDimension queryDimension = (QueryDimension) iterator
1126: .next();
1127: if (queryDimension.getGroups() == groups) {
1128: (list).add(queryDimension);
1129: }
1130: }
1131: Collections.sort(list, new Comparator() {
1132: public int compare(Object o1, Object o2) {
1133: QueryDimension dim1 = (QueryDimension) o1;
1134: QueryDimension dim2 = (QueryDimension) o2;
1135: return dim1.getLocationOrder()
1136: - dim2.getLocationOrder();
1137: }
1138: });
1139: return list;
1140: }
1141:
1142: /**
1143: * Devuelve la lista de valores de dimension excluidos para el filtro enumerado
1144: * @param dimension
1145: * @return
1146: */
1147: private Set getDimensionFilterValuesFor(int dimension) {
1148: Integer key = new Integer(dimension);
1149: Set values = (Set) getDimensionFilterValues().get(key);
1150: if (values == null) {
1151: values = new TreeSet();
1152: getDimensionFilterValues().put(key, values);
1153: }
1154: return values;
1155:
1156: }
1157:
1158: /**
1159: * Agrega un nuevo valor de dimension excluido
1160: * @param dimension
1161: * @param value
1162: */
1163: public void excludeValue(int dimension, Object value) {
1164: Set values = getDimensionFilterValuesFor(dimension);
1165: values.add(value);
1166: }
1167:
1168: /**
1169: * Elimina un valor de dimension excluido
1170: * @param dimension
1171: * @param value
1172: */
1173:
1174: public void includeValue(int dimension, Object value) {
1175: Set values = getDimensionFilterValuesFor(dimension);
1176: values.remove(value);
1177: }
1178:
1179: /**
1180: * Asocia una lista de valores excluidos a una dimensión
1181: * @param dimension
1182: * @param excludedValues
1183: */
1184: public void setExcludedValues(int dimension,
1185: Collection excludedValues) {
1186: getDimensionFilterValues().put(new Integer(dimension),
1187: excludedValues);
1188: }
1189:
1190: /**
1191: * Deveuelve la lista de valores excluidos de una dimensión
1192: * @param dimension
1193: * @return
1194: */
1195: public Set getExcludedValues(int dimension) {
1196: return (Set) getDimensionFilterValues().get(
1197: new Integer(dimension));
1198: }
1199:
1200: public boolean isVisibleTotals() {
1201: return visibleTotals;
1202: }
1203:
1204: public void setVisibleTotals(boolean visibleTotals) {
1205: this .visibleTotals = visibleTotals;
1206: }
1207:
1208: /**
1209: * Setea las metricas como visibles
1210: * @param otherMetrics
1211: */
1212: private void setMetricsVisible(Collection otherMetrics) {
1213: for (Iterator iterator = otherMetrics.iterator(); iterator
1214: .hasNext();) {
1215: QueryMetric queryMetric = (QueryMetric) iterator.next();
1216: queryMetric.setVisible(true);
1217: }
1218: }
1219:
1220: /**
1221: * Agrega las dimensiones a las QueryDimensions
1222: * @param otherDimensions
1223: */
1224: private void addDimensions(Collection otherDimensions) {
1225: getDimensions().addAll(otherDimensions);
1226: }
1227:
1228: /**
1229: * Setea como unica metrica visible la especificada
1230: * @param rankMetricName
1231: */
1232: public void setUniqueMetricVisible(String rankMetricName) {
1233: if (rankMetricName != null
1234: && !rankMetricName.equalsIgnoreCase("")) {
1235: List metrics = getMetrics();
1236: Iterator iter = metrics.iterator();
1237: while (iter.hasNext()) {
1238: QueryMetric metric = (QueryMetric) iter.next();
1239: //Solo es visible si su nombre es el especificado
1240: if (metric.getName().equalsIgnoreCase(rankMetricName)) {
1241: metric.setVisible(true);
1242: } else {
1243: metric.setVisible(false);
1244: }
1245: }
1246: }
1247: }
1248:
1249: /**
1250: * Agrega los filtros especificados al report spec.
1251: * @param filters
1252: */
1253: public void addFilters(Collection filters) {
1254: Iterator iter = filters.iterator();
1255: while (iter.hasNext()) {
1256: getReportSpec().getFilterSpecs().add(iter.next());
1257: }
1258: }
1259:
1260: /**
1261: * Quita los filtros especificados del report spec
1262: * @param filters
1263: */
1264: public void removeFilters(Collection filters) {
1265: Iterator iter = filters.iterator();
1266: while (iter.hasNext()) {
1267: getReportSpec().getFilterSpecs().remove(iter.next());
1268: }
1269: }
1270:
1271: public EnumerationCubeFilter getRankingFilter() {
1272: if (rankingFilter == null) {
1273: rankingFilter = EnumerationCubeFilter.including();
1274: }
1275: return rankingFilter;
1276: }
1277:
1278: /**
1279: * Setea la dimension como unica visible para la query
1280: * @param dimension
1281: */
1282: public void setUniqueDimension(ReportDimensionSpec dimension) {
1283: List dimensions = getDimensions();
1284: String name = dimension.getName();
1285: Iterator iterator = dimensions.iterator();
1286: while (iterator.hasNext()) {
1287: QueryDimension dim = (QueryDimension) iterator.next();
1288: if (dim.getName().equalsIgnoreCase(name)) {
1289: dim.setLocation(DimensionDefinitionLocationType.ROW);
1290: dim.setGroups(true);
1291: } else {
1292: dim.setLocation(DimensionDefinitionLocationType.HIDDEN);
1293: dim.setGroups(false);
1294: }
1295: }
1296: }
1297:
1298: public EnumerationCubeFilter getExcludeGroupFilter() {
1299: if (excludeGroupFilter == null) {
1300: excludeGroupFilter = EnumerationCubeFilter.including();
1301: }
1302: return excludeGroupFilter;
1303: }
1304:
1305: public void setExcludeGroupFilter(
1306: EnumerationCubeFilter excludeGroupFilter) {
1307: this.excludeGroupFilter = excludeGroupFilter;
1308: }
1309: }
|