0001: package com.calipso.reportgenerator.common;
0002:
0003: import com.calipso.reportgenerator.reportdefinitions.*;
0004: import com.calipso.reportgenerator.reportdefinitions.types.ReportDefinitionReportTypeType;
0005: import com.calipso.reportgenerator.reportdefinitions.types.DimensionDefinitionLocationType;
0006: import com.calipso.reportgenerator.reportdefinitions.types.FilterDefinitionFilterTypeType;
0007: import com.calipso.reportgenerator.reportcalculator.CubeDefinition;
0008: import com.calipso.reportgenerator.reportcalculator.DataTreeDefinition;
0009:
0010: import java.util.*;
0011: import java.io.Serializable;
0012: import java.math.BigDecimal;
0013:
0014: import org.apache.commons.collections.iterators.FilterIterator;
0015: import org.apache.commons.collections.Predicate;
0016:
0017: /**
0018: * Esta clase se utiliza para consilidar toda la información proveniente de un ReportDefinition y su ReportSourceDefinition
0019: * asiciado.
0020: */
0021: public class ReportSpec implements CubeDefinition, DataTreeDefinition,
0022: Serializable {
0023:
0024: private Map dimensionSpecs;
0025: private List dimensionsByIndex;
0026: private Map metricSpecs;
0027: private Map accumulableMetricSpecs;
0028: private List metricsByIndex;
0029: private List accumulableMetricsByIndex;
0030: private Map posParamValues;
0031: private Object[] dimensions;
0032: private Object[] groupingDimensions;
0033: private Object[] nonGroupingDimensions;
0034: private Object[] metrics;
0035: private Object[] accumulableMetrics;
0036: private String description;
0037: private String title;
0038: private String pageHeader;
0039: private String pageFooter;
0040: private ReportDefinitionReportTypeType reportType;
0041: private Collection preFilterSpecs;
0042: private Collection filterSpecs;
0043: private Collection dataSourceSpecs;
0044: // private String datePattern = "";
0045: private boolean cached;
0046: private String incrementalDimension;
0047: private BigDecimal expiration;
0048: private String sourceId;
0049: private String definitionId;
0050: private Map dataSourceIndexes;
0051: private String localeLanguage;
0052: private Map localizationMap;
0053: private List drillDownSpecs;
0054: private int sourceMaxRowCount;
0055: private String sourceMaxRowsDimension = "";
0056: private int maxRowCount;
0057: private String maxRowsDimension = "";
0058: private boolean visibleTotals;
0059: private Map preParamValues;
0060: private String LayoutDesign;
0061: // private String dateTimePattern = "";
0062: private String infoPage;
0063: private boolean datawarehouseSaved;
0064: private Map reportSourceIndexes;
0065:
0066: /**
0067: * Constructor con un ReportGeneratorConfiguration
0068: */
0069: public ReportSpec(
0070: ReportGeneratorConfiguration reportGeneratorConfiguration) {
0071: //datePattern = "yyyyMMdd";
0072: setLocale(reportGeneratorConfiguration.getLocaleLanguage());
0073: //setDatePattern(reportGeneratorConfiguration.getDatePattern());
0074: }
0075:
0076: /**
0077: * Devuelve un array que contiene todas las dimensiones del reporte
0078: * Implementación de la interface DataDefinition
0079: * @return
0080: */
0081: public Object[] getDimensions() {
0082: if (dimensions == null) {
0083: dimensions = getDimensionsByIndex().toArray();
0084: }
0085: return dimensions;
0086: }
0087:
0088: /**
0089: * Devuelve un array que contiene todas las métricas del reporte
0090: * Implementación de la interface DataDefinition
0091: * @return
0092: */
0093:
0094: public Object[] getMetrics() {
0095: if (metrics == null) {
0096: metrics = getMetricsByIndex().toArray();
0097: }
0098: return metrics;
0099: }
0100:
0101: /**
0102: * Devuelve un array que contiene todas las métricas acumulables del reporte
0103: * Implementación de la interface DataDefinition
0104: * @return
0105: */
0106:
0107: public Object[] getAccumulableMetrics() {
0108: if (accumulableMetrics == null) {
0109: accumulableMetrics = getAccumulableMetricsByIndex()
0110: .toArray();
0111: }
0112: return accumulableMetrics;
0113: }
0114:
0115: /**
0116: * Devuelve un Diccionario que asocia los nombres de los campos con sus indices
0117: * @return
0118: */
0119:
0120: public Map getDataSourceIndexes() {
0121: if (dataSourceIndexes == null) {
0122: dataSourceIndexes = new HashMap();
0123: }
0124: return dataSourceIndexes;
0125: }
0126:
0127: /**
0128: * Devuelve un array que contiene las dimensiones según su rol en la agrupación
0129: * @param dimensions
0130: * @param grouping
0131: * @return
0132: */
0133: private Object[] getDimensionsByGrouping(List dimensions,
0134: boolean grouping) {
0135: List dims = new ArrayList();
0136: Iterator iter = dimensions.iterator();
0137: while (iter.hasNext()) {
0138: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter
0139: .next();
0140: if (dimensionSpec.getReportIndex() >= 0
0141: && dimensionSpec.getGroups() == grouping) {
0142: dims.add(dimensionSpec);
0143: }
0144: }
0145: return dims.toArray();
0146: }
0147:
0148: /**
0149: * Devuelve un array que contiene las dimensiones que intervienen en la agrupación
0150: * @return
0151: */
0152: public Object[] getGroupingDimensions() {
0153: if (groupingDimensions == null) {
0154: groupingDimensions = getDimensionsByGrouping(
0155: getDimensionsByIndex(), true);
0156: }
0157: return groupingDimensions;
0158: }
0159:
0160: /**
0161: * Devuelve un array que contiene las dimensiones que NO intervienen en la agrupación
0162: * @return
0163: */
0164: public Object[] getNonGroupingDimensions() {
0165: if (nonGroupingDimensions == null) {
0166: nonGroupingDimensions = getDimensionsByGrouping(
0167: getDimensionsByIndex(), false);
0168: }
0169: return nonGroupingDimensions;
0170: }
0171:
0172: /**
0173: * Devuelve un Diccionario que contiene las especificaciones de las dimensiones (la clave es el nombre)
0174: * @return
0175: */
0176: public Map getDimensionSpecs() {
0177: if (dimensionSpecs == null) {
0178: dimensionSpecs = new HashMap();
0179: }
0180: return dimensionSpecs;
0181: }
0182:
0183: /**
0184: * Devuelve una lista indexada de las dimensions donde el indice corresponde al indice de las dimensiones en el
0185: * ReportSourceDefinition (y la Matrix)
0186: * @return
0187: */
0188: public List getDimensionsByIndex() {
0189: if (dimensionsByIndex == null) {
0190: dimensionsByIndex = new ArrayList();
0191: }
0192: return dimensionsByIndex;
0193: }
0194:
0195: /**
0196: * Devuelve un Diccionario que contiene las especificaciones de las métricas (la clave es el nombre)
0197: * @return
0198: */
0199: public Map getMetricSpecs() {
0200: if (metricSpecs == null) {
0201: metricSpecs = new HashMap();
0202: }
0203: return metricSpecs;
0204: }
0205:
0206: /**
0207: * Devuelve un Diccionario que contiene las especificaciones de las métricas acumulables (la clave es el nombre)
0208: * @return
0209: */
0210: public Map getAccumulableMetricSpecs() {
0211: if (accumulableMetricSpecs == null) {
0212: accumulableMetricSpecs = new HashMap();
0213: }
0214: return accumulableMetricSpecs;
0215: }
0216:
0217: /**
0218: * Devuelve una lista indexada de las métricas donde el indice corresponde al indice de las métricas en el
0219: * ReportSourceDefinition (y la Matrix)
0220: */
0221:
0222: public List getMetricsByIndex() {
0223: if (metricsByIndex == null) {
0224: metricsByIndex = new ArrayList();
0225: }
0226: return metricsByIndex;
0227: }
0228:
0229: /**
0230: * Devuelve una lista indexada de las métricas acumulables donde el indice corresponde al indice de las métricas en el
0231: * ReportSourceDefinition (y la Matrix)
0232: */
0233:
0234: public List getAccumulableMetricsByIndex() {
0235: if (accumulableMetricsByIndex == null) {
0236: accumulableMetricsByIndex = new ArrayList();
0237: }
0238: return accumulableMetricsByIndex;
0239: }
0240:
0241: /**
0242: * Inicializa los valores de los atributos a partir de un ReportSourceDefinition
0243: * @param reportSourceDefinition
0244: */
0245: public void fillFrom(ReportSourceDefinition reportSourceDefinition)
0246: throws InfoException {
0247: int dataSourceIndex = 0;
0248: int reportSourceIndex = 0;
0249: cached = reportSourceDefinition.getCached();
0250: datawarehouseSaved = reportSourceDefinition
0251: .getDatawarehouseSaved();
0252: incrementalDimension = reportSourceDefinition
0253: .getIncrementalDimension();
0254: expiration = reportSourceDefinition.getExpiration();
0255: sourceId = reportSourceDefinition.getId();
0256: sourceMaxRowCount = reportSourceDefinition.getMaxRowCount();
0257: if (reportSourceDefinition.getMaxRowsDimensionReference() != null) {
0258: sourceMaxRowsDimension = reportSourceDefinition
0259: .getMaxRowsDimensionReference();
0260: }
0261:
0262: Enumeration dimEnum = reportSourceDefinition
0263: .getDimensionSourceDefinitions()
0264: .enumerateDimensionSourceDefinition();
0265: while (dimEnum.hasMoreElements()) {
0266: DimensionSourceDefinition dimensionSourceDefinition = (DimensionSourceDefinition) dimEnum
0267: .nextElement();
0268: String name = dimensionSourceDefinition.getName();
0269: ReportDimensionSpec dimensionSpec = new ReportDimensionSpec(
0270: name);
0271: dimensionSpec.setReportSourceIndex(reportSourceIndex);
0272: getReportSourceIndexes().put(name,
0273: new Integer(reportSourceIndex));
0274: //dimensionSpec.setDatePattern(getDatePattern());
0275: //dimensionSpec.setDateTimePattern(getDateTimePattern());
0276: dimensionSpec.setDataSourceIndexes(getDataSourceIndexes());
0277: dimensionSpec
0278: .setReportSourceIndexes(getReportSourceIndexes());
0279: reportSourceIndex++;
0280: if (!dimensionSourceDefinition.getCalculated()) {
0281: dimensionSpec.setDataSourceIndex(dataSourceIndex);
0282: getDataSourceIndexes().put(name,
0283: new Integer(dataSourceIndex));
0284: dataSourceIndex++;
0285: }
0286: dimensionSpec.fillFrom(dimensionSourceDefinition,
0287: reportSourceDefinition.getMultilanguage(),
0288: getLocalizacionMap(reportSourceDefinition));
0289: addDimension(dimensionSpec);
0290: }
0291:
0292: Enumeration metEnum = reportSourceDefinition
0293: .getMetricSourceDefinitions()
0294: .enumerateMetricSourceDefinition();
0295: while (metEnum.hasMoreElements()) {
0296: MetricSourceDefinition metricSourceDefinition = (MetricSourceDefinition) metEnum
0297: .nextElement();
0298: String name = metricSourceDefinition.getName();
0299: ReportMetricSpec metricSpec = new ReportMetricSpec(name);
0300: metricSpec.setReportSourceIndex(reportSourceIndex);
0301: getReportSourceIndexes().put(name,
0302: new Integer(reportSourceIndex));
0303: metricSpec.setReportSourceIndexes(getReportSourceIndexes());
0304: metricSpec.setDataSourceIndexes(getDataSourceIndexes());
0305: reportSourceIndex++;
0306: if (!metricSourceDefinition.getCalculated()) {
0307: metricSpec.setDataSourceIndex(dataSourceIndex);
0308: getDataSourceIndexes().put(name,
0309: new Integer(dataSourceIndex));
0310: dataSourceIndex++;
0311: }
0312: metricSpec.fillFrom(metricSourceDefinition,
0313: reportSourceDefinition.getMultilanguage(),
0314: getLocalizacionMap(reportSourceDefinition));
0315: addMetric(metricSpec);
0316: }
0317: preFilterSpecs = new ArrayList();
0318: fillReportFilters(
0319: reportSourceDefinition.getFilterDefinitions(),
0320: (List) preFilterSpecs);
0321: preParamValues = ReportFilterBuilder.mergeParamValues(
0322: getPreParamValues(), reportSourceDefinition
0323: .getParameterValues());
0324: translateParamValues(preParamValues);
0325:
0326: dataSourceSpecs = new ArrayList();
0327: Enumeration dataSourcesEnum = reportSourceDefinition
0328: .getDataSourceDefinitions()
0329: .enumerateDataSourceDefinition();
0330: while (dataSourcesEnum.hasMoreElements()) {
0331: DataSourceDefinition dataSourceDefinition = (DataSourceDefinition) dataSourcesEnum
0332: .nextElement();
0333: ReportDataSourceSpec dataSourceSpec = new ReportDataSourceSpec();
0334: dataSourceSpec.fillFrom(dataSourceDefinition);
0335: dataSourceSpecs.add(dataSourceSpec);
0336: }
0337: }
0338:
0339: private Map getReportSourceIndexes() {
0340: if (reportSourceIndexes == null) {
0341: reportSourceIndexes = new HashMap();
0342: }
0343: return reportSourceIndexes;
0344: }
0345:
0346: private void translateParamValues(Map paramValues)
0347: throws InfoException {
0348: Iterator params = paramValues.entrySet().iterator();
0349: while (params.hasNext()) {
0350: Map.Entry current = (Map.Entry) params.next();
0351: ReportFilterSpec filter = getFilterSpecFromParamName(current
0352: .getKey().toString());
0353: if ((filter != null)
0354: && (filter.getFilterType() != FilterDefinitionFilterTypeType.IN)) {
0355: ReportDimensionSpec dimension = getDimensionFromName(filter
0356: .getDimensionName());
0357: if (dimension != null) {
0358: Object obj = dimension.getValueFor(current
0359: .getValue());
0360: current.setValue(obj);
0361: } else {
0362: Object obj = ReportDimensionSpec.getValueFor(
0363: current.getValue(), filter.getDataType()
0364: .getType());
0365: current.setValue(obj);
0366: //throw new InfoException(LanguageTraslator.traslate("365"));
0367: }
0368: }
0369: }
0370: }
0371:
0372: public void setPosParamValues(Map paramValues) {
0373: if (paramValues != null) {
0374: this .posParamValues = paramValues;
0375: }
0376: }
0377:
0378: /**
0379: * Agrega una métrica a al diccionario que asocia por nombre y a la lista que se utiliza para buscar por indice
0380: * @param metricSpec
0381: */
0382: private void addMetric(ReportMetricSpec metricSpec) {
0383: getMetricSpecs().put(metricSpec.getName().toUpperCase(),
0384: metricSpec);
0385: getMetricsByIndex().add(metricSpec);
0386: }
0387:
0388: /**
0389: * Agrega una dimensión a al diccionario que asocia por nombre y a la lista que se utiliza para buscar por indice
0390: * @param dimensionSpec
0391: */
0392:
0393: private void addDimension(ReportDimensionSpec dimensionSpec) {
0394: getDimensionSpecs().put(dimensionSpec.getName().toUpperCase(),
0395: dimensionSpec);
0396: getDimensionsByIndex().add(dimensionSpec);
0397: }
0398:
0399: /**
0400: * Inicializa los valores de los atributos a partir de un ReportDefinition
0401: * @param reportDefinition
0402: */
0403:
0404: public void fillFrom(ReportDefinition reportDefinition)
0405: throws InfoException {
0406: definitionId = reportDefinition.getId();
0407: boolean isMultilanguege = reportDefinition.getMultilanguage();
0408: Map localizationMap = getLocalizacionMap(reportDefinition);
0409: setDescription(traslate(isMultilanguege, localizationMap,
0410: reportDefinition.getDescription()));
0411: setPageHeader(traslate(isMultilanguege, localizationMap,
0412: reportDefinition.getPageHeding()));
0413: setPageFooter(traslate(isMultilanguege, localizationMap,
0414: reportDefinition.getPageFooter()));
0415: setTitle(traslate(isMultilanguege, localizationMap,
0416: reportDefinition.getTitle()));
0417: setReportType(reportDefinition.getReportType());
0418: maxRowCount = reportDefinition.getMaxRowCount();
0419: visibleTotals = reportDefinition.getVisibleTotals();
0420: setLayoutDesign(reportDefinition.getLayoutDesign());
0421: if (reportDefinition.getMaxRowsDimensionReference() != null) {
0422: maxRowsDimension = reportDefinition
0423: .getMaxRowsDimensionReference();
0424: }
0425:
0426: int reportIndex = 0;
0427: Enumeration dimEnum = reportDefinition
0428: .getDimensionDefinitions()
0429: .enumerateDimensionDefinition();
0430: while (dimEnum.hasMoreElements()) {
0431: DimensionDefinition dimensionDefinition = (DimensionDefinition) dimEnum
0432: .nextElement();
0433: ReportDimensionSpec dimensionSpec = getDimensionFromName(dimensionDefinition
0434: .getName().toUpperCase());
0435: dimensionSpec.setReportIndex(reportIndex);
0436: reportIndex++;
0437: dimensionSpec.fillFrom(dimensionDefinition,
0438: reportDefinition.getMultilanguage(),
0439: getLocalizacionMap(reportDefinition));
0440: }
0441:
0442: Enumeration metEnum = reportDefinition.getMetricDefinitions()
0443: .enumerateMetricDefinition();
0444: while (metEnum.hasMoreElements()) {
0445: MetricDefinition metricDefinition = (MetricDefinition) metEnum
0446: .nextElement();
0447: ReportMetricSpec metricSpec = getMetricFromName(metricDefinition
0448: .getName().toUpperCase());
0449: metricSpec.setReportIndex(reportIndex);
0450: reportIndex++;
0451: metricSpec.fillFrom(metricDefinition, reportDefinition
0452: .getMultilanguage(),
0453: getLocalizacionMap(reportDefinition));
0454: if (metricSpec.getAccumulable()) {
0455: getAccumulableMetricSpecs().put(metricSpec.getName(),
0456: metricSpec);
0457: getAccumulableMetricsByIndex().add(metricSpec);
0458: }
0459: }
0460:
0461: filterSpecs = new ArrayList();
0462: fillReportFilters(reportDefinition.getFilterDefinitions(),
0463: (List) filterSpecs);
0464: posParamValues = ReportFilterBuilder.mergeParamValues(
0465: getPosParamValues(), reportDefinition
0466: .getParameterValues());
0467: translateParamValues(posParamValues);
0468:
0469: drillDownSpecs = new ArrayList();
0470: if (reportDefinition.getDrillDownDefinitions() != null) {
0471: Enumeration drillDownEnum = reportDefinition
0472: .getDrillDownDefinitions()
0473: .enumerateDrillDownDefinition();
0474: while (drillDownEnum.hasMoreElements()) {
0475: DrillDownDefinition drillDownDefinition = (DrillDownDefinition) drillDownEnum
0476: .nextElement();
0477: DrillDownSpec drillDownSpec = new DrillDownSpec();
0478: drillDownSpec.fillFrom(drillDownDefinition);
0479: drillDownSpecs.add(drillDownSpec);
0480: }
0481: }
0482: this .infoPage = reportDefinition.getInfoPage();
0483: }
0484:
0485: /**
0486: * Obtiene la lista de las conversiones para la ubicación del ReportDefinition
0487: * @param reportDefinition
0488: * @return
0489: */
0490: private Map getLocalizacionMap(ReportDefinition reportDefinition) {
0491: if (localizationMap == null) {
0492: Localization localization = getLocalizationFromLocale(reportDefinition
0493: .getLocalizations());
0494: if (localization != null) {
0495: localizationMap = createMapLocazation(localization);
0496: }
0497: }
0498: return localizationMap;
0499: }
0500:
0501: /**
0502: * Obtiene la lista de las conversiones para la ubicación del ReportSourceDefinition
0503: * @param reportSourceDefinition
0504: * @return
0505: */
0506: private Map getLocalizacionMap(
0507: ReportSourceDefinition reportSourceDefinition) {
0508: Localization localization = getLocalizationFromLocale(reportSourceDefinition
0509: .getLocalizations());
0510: if (localization != null) {
0511: return createMapLocazation(localization);
0512: }
0513: return null;
0514: }
0515:
0516: /**
0517: * Crea un Map con la lista de los literales para las conversiones
0518: * @param localization
0519: * @return
0520: */
0521: private Map createMapLocazation(Localization localization) {
0522: Map localeMap = new Hashtable();
0523: for (int i = 0; i < localization.getLiteralsCount(); i++) {
0524: localeMap.put(localization.getLiterals()[i].getCode(),
0525: localization.getLiterals()[i].getValue());
0526: }
0527: return localeMap;
0528: }
0529:
0530: /**Obtiene el localization para el locale corespondiente
0531: *
0532: * @param localizations
0533: * @return
0534: */
0535: private Localization getLocalizationFromLocale(
0536: Localizations localizations) {
0537: Localization localization;
0538: if (localizations != null) {
0539: for (int i = 0; i < localizations.getLocalizationCount(); i++) {
0540: localization = localizations.getLocalization()[i];
0541: if (localization.getLocale().equalsIgnoreCase(
0542: getLocaleLanguage())) {
0543: return localization;
0544: }
0545: ;
0546: }
0547: }
0548: return null;
0549: }
0550:
0551: /**
0552: * Crea las especificaciones de los filtros a partir de las definitiones de filtros. Este método se utiliza tanto para
0553: * los pre-filtros como para los post-filtros
0554: * @param filterDefinitions
0555: * @param filters
0556: */
0557: private void fillReportFilters(FilterDefinitions filterDefinitions,
0558: List filters) {
0559: if (filterDefinitions != null) {
0560: for (int i = 0; i < filterDefinitions
0561: .getFilterDefinitionCount(); i++) {
0562: FilterDefinition filterDefinition = filterDefinitions
0563: .getFilterDefinition(i);
0564: ReportFilterSpec reportFilterSpec = new ReportFilterSpec();
0565: reportFilterSpec.fillFrom(filterDefinition);
0566: filters.add(reportFilterSpec);
0567: }
0568: }
0569: }
0570:
0571: /**
0572: * Busca una métrica a partir de su nombre
0573: * @param name
0574: * @return
0575: */
0576: public ReportMetricSpec getMetricFromName(String name) {
0577: return (ReportMetricSpec) getMetricSpecs().get(
0578: name.toUpperCase());
0579: }
0580:
0581: /**
0582: * Busca una métrica a partir de su indice
0583: * @param index
0584: * @return
0585: */
0586: public ReportMetricSpec getMetricFromIndex(int index) {
0587: return (ReportMetricSpec) getMetricsByIndex().get(index);
0588: }
0589:
0590: /**
0591: * Busca una Dimensión a partir de su nombre
0592: * @param name
0593: * @return
0594: */
0595: public ReportDimensionSpec getDimensionFromName(String name) {
0596: return (ReportDimensionSpec) getDimensionSpecs().get(
0597: name.toUpperCase());
0598: }
0599:
0600: /**
0601: * Busca una Dimensión a partir de su indice
0602: * @param index
0603: * @return
0604: */
0605: public ReportDimensionSpec getDimensionFromIndex(int index) {
0606: return (ReportDimensionSpec) getDimensionsByIndex().get(index);
0607: }
0608:
0609: /**
0610: * Devuelve la descripción del reporte
0611: * @return
0612: */
0613: public String getDescription() {
0614: return description;
0615: }
0616:
0617: /**
0618: * Asigna la descripción del reporte
0619: */
0620: public void setDescription(String description) {
0621: this .description = description;
0622: }
0623:
0624: /**
0625: * Devuelve el título del reporte
0626: * @return
0627: */
0628: public String getTitle() {
0629: return title;
0630: }
0631:
0632: /**
0633: * Asigna el título del reporte
0634: * @param title
0635: */
0636: public void setTitle(String title) {
0637: this .title = title;
0638: }
0639:
0640: /**
0641: * Devuelve el texto del encabezado de página
0642: * @return
0643: */
0644: public String getPageHeader() {
0645: return pageHeader;
0646: }
0647:
0648: /**
0649: * Asigna el texto del encabezado de página
0650: */
0651: public void setPageHeader(String pageHeader) {
0652: this .pageHeader = pageHeader;
0653: }
0654:
0655: /**
0656: * Devuelve el texto del pie de página
0657: * @return
0658: */
0659:
0660: public String getPageFooter() {
0661: return pageFooter;
0662: }
0663:
0664: /**
0665: * Asigna el texto del pie de pégina
0666: * @param pageFooter
0667: */
0668: public void setPageFooter(String pageFooter) {
0669: this .pageFooter = pageFooter;
0670: }
0671:
0672: /**
0673: * Devulve el tipo de Reporte (CUBE, SUM, ACCUM)
0674: * @see com.calipso.reportgenerator.reportdefinitions.types.ReportDefinitionReportTypeType
0675: * @return
0676: */
0677: public ReportDefinitionReportTypeType getReportType() {
0678: return reportType;
0679: }
0680:
0681: /**
0682: * Asigna el tipo de Reporte
0683: * @param reportType
0684: */
0685: public void setReportType(ReportDefinitionReportTypeType reportType) {
0686: this .reportType = reportType;
0687: }
0688:
0689: /**
0690: * Devuelve un diccionario que contiene los valores de los parámetros que se utilizan para evaluar los filtros
0691: * @param sourceOnly Indica si se obtienen solo los prefiltros
0692: * @return
0693: */
0694: public Map getParamValues(boolean sourceOnly) {
0695: Map param = new HashMap();
0696: param = ReportFilterBuilder.mergeParamValues(param,
0697: getPreParamValues());
0698: if (!sourceOnly || !getCached()) {
0699: param = ReportFilterBuilder.mergeParamValues(param,
0700: getPosParamValues());
0701: }
0702: return param;
0703: }
0704:
0705: /**
0706: * Debuelve un campo (Dimensión o Métrica) a aprtir de su nombre
0707: * @param name
0708: * @return
0709: */
0710: public ReportFieldSpec getFieldFromName(String name) {
0711: ReportFieldSpec fieldSpec;
0712: fieldSpec = getDimensionFromName(name);
0713: if (fieldSpec == null) {
0714: fieldSpec = getMetricFromName(name);
0715: }
0716: return fieldSpec;
0717: }
0718:
0719: /**
0720: * Devuelve una lista de dimensiones segun su ubicación de agrupación (se utiliza para reportes cube donde las
0721: * ubicaciones pueden ser ROW, COLUMN o PAGE)
0722: * @param location
0723: * @return
0724: */
0725: public Collection getDimensionsByLocation(
0726: DimensionDefinitionLocationType location) {
0727: Iterator iter = getDimensionsByIndex().iterator();
0728: ArrayList result = new ArrayList();
0729: while (iter.hasNext()) {
0730: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter
0731: .next();
0732: if (dimensionSpec.getLocation() != null
0733: && dimensionSpec.getLocation().getType() == location
0734: .getType()) {
0735: result.add(dimensionSpec);
0736: }
0737: }
0738: return result;
0739: }
0740:
0741: /**
0742: * Devuelve una lista con todas las definiciones de post-filtros
0743: * @return
0744: */
0745: public Collection getFilterSpecs() {
0746: return filterSpecs;
0747: }
0748:
0749: /**
0750: * Devuelve una lista con todas las definiciones de pre-filtros
0751: * @return
0752: */
0753: public Collection getPreFilterSpecs() {
0754: return preFilterSpecs;
0755: }
0756:
0757: /**
0758: * Devuelve una lista con las especificaciones de los DataSource
0759: * @return
0760: */
0761: public Collection getDataSourceSpecs() {
0762: return dataSourceSpecs;
0763: }
0764:
0765: /*
0766: * Devuelve el pattern para tratar el tipo de dato date
0767: * @return
0768:
0769: public String getDatePattern() {
0770: return datePattern;
0771: }*/
0772:
0773: /*
0774: * Especifica el pattern para tratar el tipo de dato date
0775: * @param datePattern
0776:
0777: public void setDatePattern(String datePattern) {
0778: if(datePattern != null && !datePattern.equals("")){
0779: this.datePattern = datePattern;
0780: }
0781: }*/
0782:
0783: /*
0784: * Devuelve el pattern para tratar el tipo de dato datetime
0785: * @return
0786:
0787: private String getDateTimePattern() {
0788: return dateTimePattern;
0789: }
0790:
0791: /*
0792: * Especifica el pattern para tratar el tipo de dato datetime
0793: * @param dateTimePattern
0794:
0795: private void setDateTimePattern(String dateTimePattern){
0796: this.dateTimePattern = dateTimePattern;
0797: }*/
0798:
0799: /**
0800: * Se utiliza para saber si el origen del reporte (Matrix) se guarda en el repositorio de DataSource
0801: * @return
0802: */
0803: public boolean getCached() {
0804: return cached;
0805: }
0806:
0807: /**
0808: * Devuel el nombre de la dimensión (de tipo fecha) que se utiliza para resolver los origenes de datos incrementales
0809: * @return
0810: */
0811: public String getIncrementalDimension() {
0812: return incrementalDimension;
0813: }
0814:
0815: /**
0816: * Devuelve le período de tiempo para el que es vigente un ReportSource cacheado
0817: * @return
0818: */
0819: public BigDecimal getExpiration() {
0820: return expiration;
0821: }
0822:
0823: /**
0824: * Devuelve el identificador del ReportSourceDefinition
0825: * @return
0826: */
0827: public String getSourceId() {
0828: return sourceId;
0829: }
0830:
0831: /**
0832: * Devuelve el identificador del ReportDefinition
0833: * @return
0834: */
0835: public String getDefinitionId() {
0836: return definitionId;
0837: }
0838:
0839: /**
0840: * Devuelve una lista de dimensiones dependiendo de su rol en la agrupación
0841: * Se utliza para los reportes estáticos y para la impresión
0842: * @param groups
0843: * @return
0844: */
0845: public Collection getDimensionsByGrouping(boolean groups) {
0846: Iterator iter = getDimensionSpecs().values().iterator();
0847: ArrayList result = new ArrayList();
0848: while (iter.hasNext()) {
0849: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) iter
0850: .next();
0851: if (dimensionSpec.getGroups() == groups) {
0852: result.add(dimensionSpec);
0853: }
0854: }
0855: return result;
0856: }
0857:
0858: /**
0859: * Se utiliza para saber si un reporte es del tipo ACCUM
0860: * @return
0861: */
0862: public boolean getAccumulable() {
0863: return getReportType().getType() == ReportDefinitionReportTypeType.ACCUM_TYPE;
0864: }
0865:
0866: /**
0867: * Asigna la infomación de localización (idioma)
0868: * @param localeLanguage
0869: */
0870: public void setLocale(String localeLanguage) {
0871: this .localeLanguage = localeLanguage;
0872: }
0873:
0874: /**
0875: * Devuelve la infomación de localización (idioma)
0876: * @return
0877: */
0878: public String getLocaleLanguage() {
0879: return localeLanguage;
0880: }
0881:
0882: /**
0883: * Traduce el string al lenguaje correspondiente
0884: * @param multilanguaje Indica si debe traducirse
0885: * @param localization lenguaje destino
0886: * @param value
0887: * @return
0888: */
0889: protected String traslate(boolean multilanguaje, Map localization,
0890: String value) {
0891: if (multilanguaje && (localization != null) && (value != null)
0892: && localization.containsKey(value)) {
0893: return localization.get(value).toString();
0894: } else {
0895: return value;
0896: }
0897: }
0898:
0899: /**
0900: * Devuelve las definiciones de drill down
0901: * @return
0902: */
0903: public List getDrillDownSpecs() {
0904: return drillDownSpecs;
0905: }
0906:
0907: /**
0908: * Retorna un filterspec a partir del nombre
0909: * @param name
0910: * @return
0911: */
0912: public ReportFilterSpec getFilterSpecFromName(String name) {
0913: ReportFilterSpec result = doGetFilterSpecFromName(
0914: getFilterSpecs(), name);
0915: if (result == null) {
0916: result = doGetFilterSpecFromName(getPreFilterSpecs(), name);
0917: }
0918: return result;
0919: }
0920:
0921: protected ReportFilterSpec doGetFilterSpecFromName(
0922: Collection filters, String name) {
0923: Iterator iterator = filters.iterator();
0924: while (iterator.hasNext()) {
0925: ReportFilterSpec reportFilterSpec = (ReportFilterSpec) iterator
0926: .next();
0927: if (reportFilterSpec.getName().equalsIgnoreCase(name)) {
0928: return reportFilterSpec;
0929: }
0930: }
0931: return null;
0932: }
0933:
0934: /**
0935: * Devuelva la cantidad máxima de Row que se incluirán en la matriz, se utiliza para limitar la cantidad de rows o para
0936: * obtener la información dividida en lotes
0937: * @return
0938: */
0939: public int getSourceMaxRowCount() {
0940: return sourceMaxRowCount;
0941: }
0942:
0943: /**
0944: * Devuelve el nombre de la dimensión que se utilizará como criterio para dividir la información de la matriz en lotes
0945: * @return
0946: */
0947: public String getSourceMaxRowsDimension() {
0948: return sourceMaxRowsDimension;
0949: }
0950:
0951: /**
0952: * Se utiliza para limitar la cantidad de row que se recuperan de la matriz
0953: * @return
0954: */
0955: public int getMaxRowCount() {
0956: return maxRowCount;
0957: }
0958:
0959: /**
0960: * Devuelve el nombre de la dimension que se utilizará como criterio para obtener una cantidad máxima de rows de la matriz
0961: * @return
0962: */
0963: public String getMaxRowsDimension() {
0964: return maxRowsDimension;
0965: }
0966:
0967: /**
0968: * Devuelve el filtro para llenar un ReportSource de forma incremental, con solo la información que le falta
0969: * @param lastExecution
0970: * @return
0971: */
0972: public ReportFilterSpec getIncrementalFilterSpec(Date lastExecution) {
0973: ReportFilterSpec filterSpec = null;
0974: String incDim = getIncrementalDimension();
0975: if (!incDim.equals("") && lastExecution != null) {
0976: filterSpec = new ReportFilterSpec();
0977: filterSpec.setName("INCREMENTAL");
0978: filterSpec
0979: .setFilterType(FilterDefinitionFilterTypeType.GREATERTHAN);
0980: filterSpec.setVisual(false);
0981: filterSpec.setDimensionName(incDim);
0982: }
0983: return filterSpec;
0984: }
0985:
0986: /**
0987: * Deveulve un filtro que se utiliza para llenar una cantidad máxima de rows en la matriz
0988: * @return
0989: */
0990: public ReportFilterSpec getSourceMaxRowsFilterSpec() {
0991: ReportFilterSpec filterSpec = null;
0992: String mxDim = getSourceMaxRowsDimension();
0993: if (!mxDim.equals("")) {
0994: filterSpec = new ReportFilterSpec();
0995: filterSpec.setName("SOURCEMAXROWS");
0996: filterSpec
0997: .setFilterType(FilterDefinitionFilterTypeType.GREATERTHAN);
0998: filterSpec.setVisual(true);
0999: filterSpec.setDimensionName(mxDim);
1000: }
1001: return filterSpec;
1002: }
1003:
1004: /**
1005: * Deveulve un filtro que se utiliza para llenar una cantidad máxima de rows de la matriz
1006: */
1007:
1008: public ReportFilterSpec getMaxRowsFilterSpec() {
1009: ReportFilterSpec filterSpec = null;
1010: String mxDim = getMaxRowsDimension();
1011: if (!mxDim.equals("")) {
1012: filterSpec = new ReportFilterSpec();
1013: filterSpec.setName("MAXROWS");
1014: filterSpec
1015: .setFilterType(FilterDefinitionFilterTypeType.GREATERTHAN);
1016: filterSpec.setVisual(true);
1017: filterSpec.setDimensionName(mxDim);
1018: }
1019: return filterSpec;
1020: }
1021:
1022: private void collectEditFilterSpecs(Collection filterSpecs,
1023: List result) {
1024: Iterator iterator = filterSpecs.iterator();
1025: while (iterator.hasNext()) {
1026: ReportFilterSpec filterSpec = (ReportFilterSpec) iterator
1027: .next();
1028: if (filterSpec.getVisual()) {
1029: result.add(filterSpec);
1030: }
1031: }
1032: }
1033:
1034: public Collection getEditFilterSpecs() {
1035: List collection = new ArrayList();
1036: collectEditFilterSpecs(getFilterSpecs(), collection);
1037: if (!getCached()) {
1038: collectEditFilterSpecs(getPreFilterSpecs(), collection);
1039: }
1040: return collection;
1041: }
1042:
1043: public Collection getNotCalculatedDimensions() {
1044: List notCalculatedDimensions = new ArrayList();
1045: /* for (Iterator iterator = dimensionSpecs.keySet().iterator(); iterator.hasNext();) {
1046: ReportDimensionSpec dimensionSpec = (ReportDimensionSpec) dimensionSpecs.get(iterator.next());
1047: if (!dimensionSpec.getCalculated()) {
1048: notCalculatedDimensions.add(dimensionSpec);
1049: }
1050: }*/
1051: Iterator iterator = getDimensionsByIndex().iterator();
1052: while (iterator.hasNext()) {
1053: ReportDimensionSpec dim = (ReportDimensionSpec) iterator
1054: .next();
1055: if (!dim.getCalculated()) {
1056: notCalculatedDimensions.add(dim);
1057: }
1058: }
1059: return notCalculatedDimensions;
1060: }
1061:
1062: /**
1063: * Indica si se deben incluir los totales de cada grupo de datos
1064: * @return
1065: */
1066: public boolean isVisibleTotals() {
1067: return visibleTotals;
1068: }
1069:
1070: /**
1071: * Devuelve una lista con las todas las columnas(Dimensiones y métricas)
1072: * int DATETIME_TYPE = 0;
1073: * int STRING_TYPE = 1;
1074: * int FLOAT_TYPE = 2;
1075: * int INTEGER_TYPE = 3;
1076: * int BOOLEAN_TYPE = 4;
1077: * @return
1078: */
1079: public List getColumnByIndex() {
1080: List column = new ArrayList();
1081: column.addAll(getDimensionsByIndex());
1082: column.addAll(getMetricsByIndex());
1083: return column;
1084: }
1085:
1086: /**
1087: * Retorna una lista con las columnas ordenadas con el tipo de dato da cada una de ellas
1088: * int DATETIME_TYPE = 0;
1089: * int STRING_TYPE = 1;
1090: * int FLOAT_TYPE = 2;
1091: * int INTEGER_TYPE = 3;
1092: * int BOOLEAN_TYPE = 4;
1093: */
1094: public List getColumnTypesByIndex() {
1095: List columnTypes = new ArrayList();
1096: Iterator itDimensions = getDimensionsByIndex().iterator();
1097: Iterator itMetrics = getMetricsByIndex().iterator();
1098:
1099: while (itDimensions.hasNext()) {
1100: ReportDimensionSpec reportDimensionSpec = (ReportDimensionSpec) itDimensions
1101: .next();
1102: if (!reportDimensionSpec.getCalculated()) {
1103: columnTypes.add(new Integer(reportDimensionSpec
1104: .getDataType().getType()));
1105: }
1106: }
1107: while (itMetrics.hasNext()) {
1108: ReportMetricSpec reportMetricSpec = (ReportMetricSpec) itMetrics
1109: .next();
1110: if (!(reportMetricSpec.getCalculated())) {
1111: columnTypes.add(new Integer(2));
1112: }
1113: }
1114: return columnTypes;
1115: }
1116:
1117: /**
1118: * Retorna un diccionario con los nombres de las columnas y los tipos de datos de cada una
1119: * int DATETIME_TYPE = 0;
1120: * int STRING_TYPE = 1;
1121: * int FLOAT_TYPE = 2;
1122: * int INTEGER_TYPE = 3;
1123: * int BOOLEAN_TYPE = 4;
1124: */
1125: public Map getColumnTypesByName() {
1126: Map columnTypes = new HashMap();
1127: Iterator itDimensions = getDimensionsByIndex().iterator();
1128: Iterator itMetrics = getMetricsByIndex().iterator();
1129:
1130: while (itDimensions.hasNext()) {
1131: ReportDimensionSpec reportDimensionSpec = (ReportDimensionSpec) itDimensions
1132: .next();
1133: if (!reportDimensionSpec.getCalculated()) {
1134: columnTypes.put(reportDimensionSpec.getName(),
1135: new Integer(reportDimensionSpec.getDataType()
1136: .getType()));
1137: }
1138: }
1139: while (itMetrics.hasNext()) {
1140: ReportMetricSpec reportMetricSpec = (ReportMetricSpec) itMetrics
1141: .next();
1142: if (!(reportMetricSpec.getCalculated())) {
1143: columnTypes.put(reportMetricSpec.getName(),
1144: new Integer(2));
1145: }
1146: }
1147: return columnTypes;
1148: }
1149:
1150: public Map getPosParamValues() {
1151: if (posParamValues == null) {
1152: posParamValues = new HashMap();
1153: }
1154: return posParamValues;
1155: }
1156:
1157: public Map getPreParamValues() {
1158: if (preParamValues == null) {
1159: preParamValues = new HashMap();
1160: }
1161: return preParamValues;
1162:
1163: }
1164:
1165: /**
1166: * Devuelve una coleccion conm las metricas no calculadas considerando el indice de las mismas.
1167: * @return
1168: */
1169: public Collection getNotCalculatedMetrics() {
1170: List notCalculatedMetrics = new ArrayList();
1171: for (Iterator iterator = getMetricsByIndex().iterator(); iterator
1172: .hasNext();) {
1173: ReportMetricSpec metricSpec = (ReportMetricSpec) iterator
1174: .next();
1175: if (!metricSpec.getCalculated()) {
1176: notCalculatedMetrics.add(metricSpec);
1177: }
1178: }
1179: return notCalculatedMetrics;
1180: }
1181:
1182: /**
1183: * Devuelve el nombre de la dimención según el indice sin contemplar las columnas calculadas
1184: * @param index
1185: * @return
1186: */
1187: public String getDataSourceIndexNameByIndex(int index) {
1188: Iterator iter = getDataSourceIndexes().entrySet().iterator();
1189: boolean find = false;
1190: String returnValue = "";
1191: while (iter.hasNext() && !find) {
1192: Map.Entry entry = (Map.Entry) iter.next();
1193: if (((Integer) entry.getValue()).intValue() == index) {
1194: returnValue = entry.getKey().toString();
1195: find = true;
1196: }
1197: }
1198: return returnValue;
1199: }
1200:
1201: public void setLayoutDesign(String layoutDesign) {
1202: LayoutDesign = layoutDesign;
1203: }
1204:
1205: public String getLayoutDesign() {
1206: return LayoutDesign;
1207: }
1208:
1209: public ReportFilterSpec getFilterSpecFromParamName(String paramName) {
1210: ReportFilterSpec filterSpec = doGetFilterSpecFromParamName(
1211: getFilterSpecs(), paramName);
1212: if (filterSpec == null) {
1213: filterSpec = doGetFilterSpecFromParamName(
1214: getPreFilterSpecs(), paramName);
1215: }
1216: return filterSpec;
1217: }
1218:
1219: protected ReportFilterSpec doGetFilterSpecFromParamName(
1220: Collection filters, String paramName) {
1221: if (filters != null) {
1222: Iterator iterator = filters.iterator();
1223: while (iterator.hasNext()) {
1224: ReportFilterSpec reportFilterSpec = (ReportFilterSpec) iterator
1225: .next();
1226: if (reportFilterSpec.includesParam(paramName)) {
1227: return reportFilterSpec;
1228: }
1229: }
1230: }
1231: return null;
1232: }
1233:
1234: public Object[] getVisibleDimensionsByGrouping(boolean grouping) {
1235: Collection result = new Vector();
1236: Object[] dims;
1237: if (grouping) {
1238: dims = getGroupingDimensions();
1239: } else {
1240: dims = getNonGroupingDimensions();
1241: }
1242: for (int i = 0; i < dims.length; i++) {
1243: if (((ReportDimensionSpec) dims[i]).getLocation() != null) {
1244: result.add(dims[i]);
1245: }
1246: }
1247: return result.toArray();
1248: }
1249:
1250: public String getInfoPage() {
1251: return infoPage;
1252: }
1253:
1254: public void setInfoPage(String infoPage) {
1255: this .infoPage = infoPage;
1256: }
1257:
1258: public boolean getDatawarehouseSaved() {
1259: return this .datawarehouseSaved;
1260: }
1261:
1262: public Iterator getIndexedColumns() {
1263: Predicate predicate = new Predicate() {
1264: public boolean evaluate(Object o) {
1265: return ((ReportDimensionSpec) o).isIndexed();
1266: }
1267: };
1268: return new FilterIterator(getDimensionsByIndex().iterator(),
1269: predicate);
1270: }
1271: }
|