0001: package com.calipso.reportgenerator.reportmanager;
0002:
0003: import com.calipso.reportgenerator.reportdefinitions.ReportDefinition;
0004: import com.calipso.reportgenerator.reportdefinitions.ReportSourceDefinition;
0005: import com.calipso.reportgenerator.reportdefinitions.ReportView;
0006: import com.calipso.reportgenerator.reportdefinitions.types.ReportDefinitionReportTypeType;
0007: import com.calipso.reportgenerator.services.FileSystemResolver;
0008: import com.calipso.reportgenerator.reportcalculator.Matrix;
0009: import com.calipso.reportgenerator.common.*;
0010: import com.calipso.reportgenerator.reportmanager.UsersRepository;
0011:
0012: import java.util.*;
0013: import java.io.*;
0014:
0015: import org.apache.commons.logging.Log;
0016: import org.apache.commons.vfs.FileSystemManager;
0017: import org.apache.commons.vfs.FileObject;
0018: import org.exolab.castor.xml.Unmarshaller;
0019: import com.calipso.reportgenerator.common.InfoException;
0020: import net.sf.jasperreports.engine.*;
0021: import net.sf.jasperreports.engine.export.JRXlsExporter;
0022: import net.sf.jasperreports.engine.export.JRCsvExporter;
0023:
0024: /**
0025: * Esta clase es el único punto de ingreso al generador de reportes.
0026: * Para ejecutar un reporte se instancia un ReportManager.
0027: * Es el encargado de integrar el funcionamiento con el Pivot
0028: * y de mantener los repositorios de las definiciones de reportes
0029: * y reportes precalculados.
0030: * Esta clase representa la API a la que llaman todos los módulos externos
0031: */
0032:
0033: public class ReportManager implements IReportManager, Serializable {
0034:
0035: private HashMap activeReports;
0036: private int lastHandle;
0037: private ReportDefinitionRepository reportDefinitionRepository;
0038: private ReportSourceDefinitionRepository reportSourceDefinitionRepository;
0039: private ReportSourceRepository reportSourceRepository;
0040: private ReportViewRepository reportViewRepository;
0041: private ReportGeneratorConfiguration reportGeneratorConfiguration;
0042: private TempRepository tempRepository;
0043:
0044: /**
0045: * Inicializa una instancia de <code>ReportManager</code>
0046: * @param reportGeneratorConfiguration Configuración del report manager
0047: */
0048: public ReportManager(
0049: ReportGeneratorConfiguration reportGeneratorConfiguration)
0050: throws InfoException {
0051: ReportManagerLogger.debug(LanguageTraslator.traslate("159"));
0052: if (reportGeneratorConfiguration == null) {
0053: throw new InfoException(LanguageTraslator.traslate("1"));
0054: } else {
0055: this .reportGeneratorConfiguration = reportGeneratorConfiguration;
0056: }
0057: }
0058:
0059: /**
0060: * Constructor utilizado para el caso que se crea el report manager distribuido y la clase por demanda. Se debe ejecutar luego de este el init de la interfase IReportManager.
0061: * @throws InfoException
0062: */
0063: public ReportManager() throws InfoException {
0064:
0065: }
0066:
0067: /**
0068: * Crea una instancia de <code>ReportSpec</code> que contiene toda la información de <code>ReportDefinition</code> y
0069: * <code>ReportSourceDefinition</code> necesaria para resolver el reporte
0070: * @param reportDefinition
0071: * @return
0072: * @throws InfoException
0073: */
0074: public ReportSpec getReportSpec(ReportDefinition reportDefinition)
0075: throws InfoException {
0076: ReportManagerLogger.debug(LanguageTraslator.traslate("158")
0077: + ":" + reportDefinition.getId());
0078: ReportSpec reportSpec = new ReportSpec(
0079: reportGeneratorConfiguration);
0080: ReportSourceDefinition reportSourceDefinitionTmp;
0081: reportSourceDefinitionTmp = getReportSourceDefinitionFromID(reportDefinition
0082: .getReportSource());
0083: reportSpec.fillFrom(reportSourceDefinitionTmp);
0084: reportSpec.fillFrom(reportDefinition);
0085: return reportSpec;
0086: }
0087:
0088: /**
0089: * Crea una instancia de <code>ReportSpec</code> que contiene toda la información de <code>ReportDefinition</code> y
0090: * <code>ReportSourceDefinition</code> necesaria para resolver el reporte
0091: * @param reportDefinition
0092: * @param reportSourceDef
0093: * @return
0094: * @throws InfoException
0095: */
0096: public ReportSpec getReportSpec(ReportDefinition reportDefinition,
0097: ReportSourceDefinition reportSourceDef)
0098: throws InfoException {
0099: ReportManagerLogger.debug(LanguageTraslator.traslate("158")
0100: + ":" + reportDefinition.getId());
0101: ReportSpec reportSpec = new ReportSpec(
0102: reportGeneratorConfiguration);
0103: reportSpec.fillFrom(reportSourceDef);
0104: reportSpec.fillFrom(reportDefinition);
0105: return reportSpec;
0106: }
0107:
0108: /**
0109: * Crea una instancia de <code>ReportSpec</code> que contiene toda la información de <code>ReportSourceDefinition</code> y
0110: * necesaria
0111: * @param reportSourceDefinition
0112: * @return
0113: * @throws InfoException
0114: */
0115: public ReportSpec getReportSpec(
0116: ReportSourceDefinition reportSourceDefinition)
0117: throws InfoException {
0118: ReportSpec reportSpec = new ReportSpec(
0119: reportGeneratorConfiguration);
0120: reportSpec.fillFrom(reportSourceDefinition);
0121: return reportSpec;
0122: }
0123:
0124: /**
0125: * Crea un <code>Report</code> a partir del identificador de su definición (<code>ReportDefinition</code>)
0126: * @param reportDefId
0127: * @return
0128: * @throws InfoException Si no se pudo crear el reporte
0129: */
0130: protected Report newReportFrom(String reportDefId)
0131: throws InfoException {
0132: if (reportDefId.equals("")) {
0133: throw new InfoException(LanguageTraslator.traslate("2"));
0134: } else {
0135: return newReportFrom(getReportDefinitionFromID(reportDefId));
0136: }
0137: }
0138:
0139: /**
0140: * Crea un <code>Report</code> a partir de una definición de reporte (<code>ReportDefinition</code>)
0141: * @param reportDef
0142: * @return
0143: * @throws InfoException Si no se pudo crear el Reporte
0144: */
0145: protected Report newReportFrom(ReportDefinition reportDef)
0146: throws InfoException {
0147: ReportSource source;
0148: if (reportDef == null) {
0149: throw new InfoException(LanguageTraslator.traslate("3"));
0150: } else {
0151: ReportSpec reportSpec = null;
0152: try {
0153: reportSpec = getReportSpec(reportDef);
0154: source = getReportSource(reportSpec,
0155: getReportSourceDefinitionFromID(reportDef
0156: .getReportSource()));
0157: } catch (InfoException e) {
0158: throw new InfoException(LanguageTraslator.traslate("4")
0159: + ":" + reportDef.getId(), e);
0160: }
0161: Report report = null;
0162: if ((reportSpec.getReportType().toString()
0163: .equalsIgnoreCase(ReportDefinitionReportTypeType.CUBE
0164: .toString()))
0165: || (reportSpec.getReportType().toString()
0166: .equalsIgnoreCase(ReportDefinitionReportTypeType.CHARTCUBE
0167: .toString()))) {
0168: report = new CubeReport(reportSpec, source,
0169: reportGeneratorConfiguration);
0170: } else if (reportSpec.getReportType().toString()
0171: .equalsIgnoreCase(
0172: ReportDefinitionReportTypeType.ACCUM
0173: .toString())) {
0174: report = new StaticReport(reportSpec, source,
0175: reportGeneratorConfiguration);
0176: }
0177: return report;
0178: }
0179: }
0180:
0181: /**
0182: * Crea un <code>Report</code> a partir del id de una definición de reporte (<code>ReportDefinition</code>).
0183: * También recibe los valores de parámetros, que pueden contener valores para los pre-filtros (esto solo es
0184: * aplicable a Reportes no cacheados)
0185: * @param reportDefId
0186: * @param paramValues
0187: * @return
0188: * @throws InfoException Si no se pudo generar el reporte
0189: */
0190: protected Report newReportFrom(String reportDefId, Map paramValues)
0191: throws InfoException {
0192: if (reportDefId.equals("")) {
0193: throw new InfoException(LanguageTraslator.traslate("5"));
0194: } else {
0195: return newReportFrom(
0196: getReportDefinitionFromID(reportDefId), paramValues);
0197: }
0198: }
0199:
0200: /**
0201: * Crea un <code>Report</code> a partir de una definición de reporte (<code>ReportDefinition</code>).
0202: * También recibe los valores de parámetros, que pueden contener valores para los pre-filtros (esto solo es
0203: * aplicable a Reportes no cacheados)
0204: * @param reportDef
0205: * @param paramValues
0206: * @return
0207: * @throws InfoException Si no se pudo crear el reporte
0208: */
0209:
0210: protected Report newReportFrom(ReportDefinition reportDef,
0211: Map paramValues) throws InfoException {
0212: ReportSource source;
0213: if (reportDef == null) {
0214: throw new InfoException(LanguageTraslator.traslate("6"));
0215: } else {
0216: ReportSpec reportSpec = getReportSpec(reportDef);
0217: ReportSourceDefinition reportSourceDefinition = getReportSourceDefinitionFromID(reportDef
0218: .getReportSource());
0219: Report report = null;
0220: if (reportSourceDefinition.getCached()) {
0221: report = newReportFrom(reportDef);
0222: } else {
0223: source = getReportSource(reportSpec,
0224: reportSourceDefinition, paramValues);
0225: if ((reportSpec.getReportType().toString()
0226: .equalsIgnoreCase(ReportDefinitionReportTypeType.CUBE
0227: .toString()))
0228: || (reportSpec.getReportType().toString()
0229: .equalsIgnoreCase(ReportDefinitionReportTypeType.CHARTCUBE
0230: .toString()))) {
0231: report = new CubeReport(reportSpec, source,
0232: reportGeneratorConfiguration);
0233: } else if (reportSpec.getReportType().toString()
0234: .equalsIgnoreCase(
0235: ReportDefinitionReportTypeType.ACCUM
0236: .toString())) {
0237: report = new StaticReport(reportSpec, source,
0238: reportGeneratorConfiguration);
0239: }
0240: }
0241: if (report != null) {
0242: return report;
0243: } else {
0244: throw new InfoException(LanguageTraslator.traslate("7")
0245: + ":" + reportDef.getId());
0246: }
0247: }
0248: }
0249:
0250: /**
0251: * Crea un Origen de Datos de Reporte (<code>ReportSource</code>) a partir de su definición (<code>ReportSourceDefinition</code>)
0252: * y aplicándole los valores de parámetros recibidos a los pre-filtros.
0253: * @param reportSourceDefinition
0254: * @param paramValues
0255: * @return
0256: * @throws InfoException Si no se pudo obtener el origen de dato
0257: */
0258: protected ReportSource getReportSource(ReportSpec reportSpec,
0259: ReportSourceDefinition reportSourceDefinition,
0260: Map paramValues) throws InfoException {
0261: ReportSource reportSource = null;
0262: if (reportSourceDefinition == null) {
0263: throw new InfoException(LanguageTraslator.traslate("8"));
0264: } else {
0265: reportSource = new ReportSource(reportSpec, paramValues,
0266: reportGeneratorConfiguration);
0267: return reportSource;
0268: }
0269: }
0270:
0271: /**
0272: * Crea un Origen de Datos de Reporte (<code>ReportSource</code>) a partir de su definición (<code>ReportSourceDefinition</code>)
0273: * resolviendo la obtención desde el cache, y el almacenamiento del mismo en caso de que un reporte cacheado se ejecute por
0274: * primera vez o en los reportes incrementales.
0275: * @param reportSpec
0276: * @return
0277: * @throws InfoException Si no se puede obtener el report source
0278: */
0279: protected ReportSource getReportSource(ReportSpec reportSpec,
0280: ReportSourceDefinition sourceDefinition)
0281: throws InfoException {
0282: ReportManagerLogger.debug(LanguageTraslator.traslate("160")
0283: + ":" + reportSpec.getDescription());
0284: ReportSource reportSource = null;
0285: if (reportSpec == null) {
0286: throw new InfoException(LanguageTraslator.traslate("9"));
0287: } else {
0288: boolean cached = reportSpec.getCached();
0289: boolean incremental = !reportSpec.getIncrementalDimension()
0290: .equals("");
0291: if (cached) {
0292: try {
0293: //reportSource = getReportSourceRepository().load(reportSpec);
0294: reportSource = getReportSourceRepository().load(
0295: getReportGeneratorConfiguration(),
0296: reportSpec, sourceDefinition);
0297: } catch (InfoException e) {
0298: e.printStackTrace();
0299: throw new InfoException(LanguageTraslator
0300: .traslate("10"), e);
0301: }
0302: if (incremental) {
0303: if (reportSource == null) {
0304: try {
0305: reportSource = new ReportSource(reportSpec,
0306: reportGeneratorConfiguration);
0307: } catch (Exception e) {
0308: throw new InfoException(LanguageTraslator
0309: .traslate("11"), e);
0310: }
0311: boolean saved = getReportSourceRepository()
0312: .saveIncrementalSource(
0313: reportSource,
0314: getReportGeneratorConfiguration()
0315: .isCsvSerialized());
0316: if (!saved) {
0317: getReportSourceRepository().saveNewSource(
0318: reportSource,
0319: getReportGeneratorConfiguration()
0320: .isCsvSerialized());
0321: }
0322: }
0323: }
0324: }
0325: if (reportSource == null) {
0326: reportSource = new ReportSource(reportSpec,
0327: reportGeneratorConfiguration);
0328: if (cached) {
0329: getReportSourceRepository().saveNewSource(
0330: reportSource,
0331: getReportGeneratorConfiguration()
0332: .isCsvSerialized());
0333: }
0334: }
0335: return reportSource;
0336: }
0337: }
0338:
0339: /** Inicializa la ejecución de reporte para una aplicación cliente, este método debe utilizarse para preparar reportes
0340: * cacheados, en este tipo de reporte los valores de los parámetros de los pre-filtros no pueden ser modificados por el
0341: * usuario y se utilizan los que figuran en la definición
0342: * @param reportDef definición de reporte
0343: * @return devuelve un identificador de la instancia del reporte en la sesión,
0344: * que se debe utilizar para sucesivas operaciones.
0345: * @throws InfoException Si no se pudo ejecutar el prepare
0346: */
0347: public int PrepareReport(ReportDefinition reportDef)
0348: throws InfoException {
0349: Report report = null;
0350: if (reportDef == null) {
0351: throw new InfoException(LanguageTraslator.traslate("12"));
0352: } else {
0353: ReportManagerLogger.debug(LanguageTraslator.traslate("196")
0354: + ":" + reportDef.getId());
0355: report = newReportFrom(reportDef);
0356: if (report != null) {
0357: int handle = registerReport(report);
0358: return handle;
0359: }
0360: throw new InfoException(LanguageTraslator.traslate("13")
0361: + ":" + reportDef.getId());
0362: }
0363: }
0364:
0365: /**
0366: * Inicializa la ejecución de reporte para una aplicación cliente, este método debe utilizarse para preparar reportes
0367: * no cacheados, en el parámetro <code>paramValues</code> se pueden incluir valores de parámetros para pre-filtros.
0368: * @param reportDef
0369: * @param paramValues
0370: * @return
0371: * @throws InfoException Si no se ejecutó el prepare
0372: */
0373: public int PrepareReport(ReportDefinition reportDef, Map paramValues)
0374: throws InfoException {
0375: Report report = null;
0376: if (reportDef == null) {
0377: throw new InfoException(LanguageTraslator.traslate("14"));
0378: } else {
0379: ReportManagerLogger.debug(LanguageTraslator.traslate("196")
0380: + ":" + reportDef.getId());
0381: report = newReportFrom(reportDef, paramValues);
0382: if (report != null) {
0383: int handle = registerReport(report);
0384: return handle;
0385: }
0386: throw new InfoException(LanguageTraslator.traslate("15")
0387: + ":" + reportDef.getId());
0388: }
0389: }
0390:
0391: /**
0392: * Da por terminada la ejecución de un reporte para una aplicación cliente
0393: * @param handle identificador de la instancia del reporte en la sesión
0394: */
0395: public void ReleaseReport(int handle) {
0396: try {
0397: ReportManagerLogger.debug(LanguageTraslator.traslate("197")
0398: + ":"
0399: + getReportFrom(handle).getReportSpec()
0400: .getDefinitionId());
0401: } catch (InfoException e) {
0402: ReportManagerLogger
0403: .error(LanguageTraslator.traslate("198"));
0404: }
0405: unRegisterReport(handle);
0406: }
0407:
0408: /**
0409: * Devuelve una Definición de Reporte a partir de un identificador
0410: * @param id identificador de Definición de Reporte
0411: * @return devuelve la Definición de Reporte correspondiente
0412: * @throws InfoException Si no se puede acceder a la definición
0413: */
0414: public ReportDefinition getReportDefinitionFromID(String id)
0415: throws InfoException {
0416: if (id.equals("")) {
0417: throw new InfoException(LanguageTraslator.traslate("16"));
0418: } else {
0419: return getReportDefinitionRepository().loadFromID(id);
0420: }
0421: }
0422:
0423: /**
0424: * Devuelve una Definición de Origen de Datos a partir de un identificador
0425: * @param reportSourceDefinitionId identificador de Definición de Origen de Datos
0426: * @return devuelve la Definición de Origen de Datos correspondiente
0427: * @throws InfoException Si no se puede acceder a la definición
0428: */
0429:
0430: public ReportSourceDefinition getReportSourceDefinitionFromID(
0431: String reportSourceDefinitionId) throws InfoException {
0432: if (reportSourceDefinitionId.equals("")) {
0433: throw new InfoException(LanguageTraslator.traslate("17"));
0434: } else {
0435: return getReportSourceDefinitionRepository().loadFromID(
0436: reportSourceDefinitionId);
0437: }
0438: }
0439:
0440: /**
0441: * Inicializa el report manager
0442: * @param reportGeneratorConfiguration
0443: * @throws InfoException
0444: */
0445: public void init(
0446: ReportGeneratorConfiguration reportGeneratorConfiguration)
0447: throws InfoException {
0448: if (this .reportGeneratorConfiguration == null) {
0449: this .reportGeneratorConfiguration = reportGeneratorConfiguration;
0450: }
0451: }
0452:
0453: /**
0454: * Procesa una Definicion de Origen de datos de un reporte y lo graba en el repositorio correspondiente.
0455: * Se utiliza para preprocesar reportes marcados como <Code>Cached</Code>
0456: * @param reportSourceDefinitionId
0457: * @throws InfoException Si no se puede preparar el origen de dato
0458: */
0459: public void prepareReportSource(String reportSourceDefinitionId)
0460: throws InfoException {
0461: ReportSource source = null;
0462: if (reportSourceDefinitionId.equals("")) {
0463: throw new InfoException(LanguageTraslator.traslate("18"));
0464: } else {
0465: ReportManagerLogger.debug(LanguageTraslator.traslate("161")
0466: + ":" + reportSourceDefinitionId);
0467: ReportSourceDefinition reportSourceDefinition = getReportSourceDefinitionFromID(reportSourceDefinitionId);
0468: ReportSpec reportSpec = new ReportSpec(
0469: getReportGeneratorConfiguration());
0470: reportSpec.fillFrom(reportSourceDefinition);
0471: source = getReportSource(reportSpec, reportSourceDefinition);
0472: }
0473: if (source == null) {
0474: throw new InfoException(LanguageTraslator.traslate("19")
0475: + ":" + reportSourceDefinitionId);
0476: }
0477:
0478: }
0479:
0480: /**
0481: * Devuelve todas las Definiciones de Reporte registradas en el Administrador de Reportes
0482: * @return devuelve todas las Definiciones de Reporte correspondientes
0483: * @throws InfoException
0484: */
0485:
0486: public Map getReportDefinitions() throws InfoException {
0487: try {
0488: return getReportDefinitionRepository().getAllDefinitions();
0489: } catch (Exception e) {
0490: throw new InfoException(LanguageTraslator.traslate("20"), e);
0491: }
0492: }
0493:
0494: /**
0495: * Devuelve todas las Definiciones de Origen de Datos registradas en el Administrador de Reportes
0496: * @return devuelve todas las Definiciones de Origen de Datos correspondientes
0497: * @throws InfoException
0498: */
0499: public Map getReportSourceDefinitions() throws InfoException {
0500: try {
0501: return getReportSourceDefinitionRepository()
0502: .getAllDfefinitions();
0503: } catch (Exception e) {
0504: throw new InfoException(LanguageTraslator.traslate("21"), e);
0505: }
0506:
0507: }
0508:
0509: /**
0510: * Devuelve todas las Definiciones de Reporte asociadas a una entidad (a través del atributo <code>Entity</code> de
0511: * la definición de reporte
0512: * @param entityID identificador de la entidad externa asociada a Definiciones de Reporte
0513: * @return devuelve las Definicines de Reporte asociadas a la entidad especificada
0514: * @throws InfoException Si no se pudo obtener la lista
0515: */
0516: public Map getReportsForEntity(String entityID)
0517: throws InfoException {
0518: if (entityID.equals("")) {
0519: throw new InfoException(LanguageTraslator.traslate("22"));
0520: } else {
0521: try {
0522: return getReportDefinitionRepository()
0523: .getAllDfefinitionForEntity(entityID);
0524: } catch (Exception e) {
0525: throw new InfoException(LanguageTraslator
0526: .traslate("23")
0527: + ":" + entityID, e);
0528: }
0529: }
0530: }
0531:
0532: /**
0533: * Ejecuta una acción sobre un reporte
0534: *
0535: * @param handle identificador del reporte preparado
0536: * @param actionName nombre de la acción que se desea ejecutar
0537: * @param params información obtenida de las dimensiones y métricas seleccionadas al solicitar
0538: * la ejecución de la acción. Por ahora figura como <code>Object</colde> porque no está definida la
0539: * estructura que será de proveer todos los datos necesarios
0540: */
0541: public void ExecuteAction(int handle, String actionName,
0542: Object params) {
0543:
0544: }
0545:
0546: public void saveReportDefinition(String reportDefinitionId)
0547: throws InfoException {
0548: }
0549:
0550: public void saveReportSourceDefinition(
0551: String reportSourceDefinitionId) throws InfoException {
0552: }
0553:
0554: /**
0555: * Devuelve la clave para el diccionario interno que almacena los reportes activos
0556: * @param handle
0557: * @return
0558: */
0559: private Object keyFromHandle(int handle) {
0560: Object key = new Integer(handle);
0561: return key;
0562: }
0563:
0564: /**
0565: * Genera claves numéricas para mantener un diccionario de reportes activos
0566: * @return
0567: */
0568: private int getNewHandle() {
0569: return lastHandle++;
0570: }
0571:
0572: /**
0573: * Diccionario de reportes activos
0574: * @return
0575: */
0576: protected HashMap getActiveReports() {
0577: if (activeReports == null) {
0578: activeReports = new HashMap();
0579: }
0580: return activeReports;
0581: }
0582:
0583: /**
0584: * Registra un reporte en el diccionario de reportes activos
0585: * @param report
0586: * @return
0587: */
0588: protected int registerReport(Report report) {
0589: int handle = getNewHandle();
0590: getActiveReports().put(keyFromHandle(handle), report);
0591: return handle;
0592: }
0593:
0594: /**
0595: * Elimina un reporte de la lista de reportes activos
0596: * @param handle
0597: */
0598: protected void unRegisterReport(int handle) {
0599: getActiveReports().remove(keyFromHandle(handle));
0600: }
0601:
0602: /**
0603: * Devuelve un reporte activo del diccionario a partir de su clave
0604: * @param handle
0605: * @return
0606: * @throws InfoException
0607: */
0608: protected Report getReportFrom(int handle) throws InfoException {
0609: Object key = keyFromHandle(handle);
0610: if (getActiveReports().containsKey(key)) {
0611: return (Report) getActiveReports().get(key);
0612: }
0613: throw new InfoException(LanguageTraslator.traslate("24"));
0614: }
0615:
0616: /**
0617: * Devuelve el Repositorio de Definitiones de Reporte (<code>ReportDefinition</code>)
0618: * @return
0619: */
0620: protected ReportDefinitionRepository getReportDefinitionRepository() {
0621: if (reportDefinitionRepository == null) {
0622: reportDefinitionRepository = new ReportDefinitionRepository(
0623: reportGeneratorConfiguration
0624: .getReportDefinitionRepositoryPath(),
0625: reportGeneratorConfiguration);
0626: }
0627: return reportDefinitionRepository;
0628: }
0629:
0630: /**
0631: * Devuelve el Repositorio de Definitiones de Origen de Reporte (<code>ReportSourceDefinition</code>)
0632: * @return
0633: */
0634: protected ReportSourceDefinitionRepository getReportSourceDefinitionRepository() {
0635: if (reportSourceDefinitionRepository == null) {
0636: reportSourceDefinitionRepository = new ReportSourceDefinitionRepository(
0637: reportGeneratorConfiguration
0638: .getReportSourceDefinitionRepositoryPath(),
0639: reportGeneratorConfiguration);
0640: }
0641: return reportSourceDefinitionRepository;
0642: }
0643:
0644: /**
0645: * Devuelve el Repositorio de Origenes de Reporte (<code>ReportSource</code>)
0646: * Estos son los reportes pre-procesaros (cacheados) y incrementales
0647: * @return
0648: */
0649: protected ReportSourceRepository getReportSourceRepository() {
0650: if (reportSourceRepository == null) {
0651: reportSourceRepository = new ReportSourceRepository(
0652: reportGeneratorConfiguration
0653: .getReportSourceRepositoryPath(),
0654: reportGeneratorConfiguration);
0655: }
0656: return reportSourceRepository;
0657: }
0658:
0659: /**
0660: * Devuelve el Repositorio de Vistas de Reportes
0661: * @return
0662: */
0663: protected ReportViewRepository getReportViewRepository() {
0664: if (reportViewRepository == null) {
0665: reportViewRepository = new ReportViewRepository(
0666: reportGeneratorConfiguration
0667: .getReportViewRepositoryPath(),
0668: reportGeneratorConfiguration);
0669: }
0670: return reportViewRepository;
0671: }
0672:
0673: /**
0674: * Almacena en el repositorio una definición de reporte
0675: * cumplido el plazo de vigencia
0676: * @param reportDefinition Definición de reporte que se desea guardar
0677: * @throws InfoException Si no se pudo grabar la definición
0678: */
0679: public void saveReportDefinition(ReportDefinition reportDefinition)
0680: throws InfoException {
0681: if (reportDefinition == null) {
0682: throw new InfoException(LanguageTraslator.traslate("25"));
0683: } else {
0684: try {
0685: ReportManagerLogger.debug(LanguageTraslator
0686: .traslate("162")
0687: + ":" + reportDefinition.getId());
0688: getReportDefinitionRepository().save(reportDefinition);
0689: } catch (InfoException e) {
0690: throw new InfoException(LanguageTraslator
0691: .traslate("26")
0692: + ":" + reportDefinition.getId(), e);
0693: }
0694: }
0695: }
0696:
0697: /**
0698: * Almacena en el repositorio una definición de origen de datos
0699: * cumplido el plazo de vigencia
0700: * @param reportSourceDefinition Definición de Origen de Datos que se desea guardar
0701: * @throws InfoException Si no se pudo guardar le definición
0702: */
0703:
0704: public void saveReportSourceDefinition(
0705: ReportSourceDefinition reportSourceDefinition)
0706: throws InfoException {
0707: if (reportSourceDefinition == null) {
0708: throw new InfoException(LanguageTraslator.traslate("27"));
0709: } else {
0710: ReportManagerLogger.debug(LanguageTraslator.traslate("163")
0711: + ":" + reportSourceDefinition.getId());
0712: getReportSourceDefinitionRepository().save(
0713: reportSourceDefinition);
0714: }
0715: }
0716:
0717: /**
0718: * Se utiliza para forzar la caducidad de un reporte cacheado o incrementeal aunque no se haya
0719: * cumplido el plazo de vigencia
0720: * @param reportSourceDefinitionId identificador de la Definición de Origen de Datos que se desea invalidar
0721: * @throws InfoException Si no se pudo invalidar un origen de dato cacheado
0722: */
0723: public void invalidateReportSource(String reportSourceDefinitionId)
0724: throws InfoException {
0725: ReportManagerLogger.debug(LanguageTraslator.traslate("164")
0726: + ":" + reportSourceDefinitionId);
0727: ReportSourceDefinition reportSourceDefinition = null;
0728: reportSourceDefinition = getReportSourceDefinitionRepository()
0729: .loadFromID(reportSourceDefinitionId);
0730: if (reportSourceDefinition != null) {
0731: invalidateReportSource(reportSourceDefinition);
0732: } else {
0733: throw new InfoException(LanguageTraslator.traslate("28")
0734: + ":" + reportSourceDefinitionId);
0735: }
0736: }
0737:
0738: /**
0739: * Se utiliza para forzar la caducidad de un reporte cacheado o incremental aunque no se haya
0740: * cumplido el plazo de vigencia
0741: * @param reportSourceDefinition Definición de Origen de Datos que se desea invalidar
0742: * @throws InfoException Si no se pudo invalidar el origen de dato
0743: */
0744: public void invalidateReportSource(
0745: ReportSourceDefinition reportSourceDefinition)
0746: throws InfoException {
0747: if (reportSourceDefinition == null) {
0748: throw new InfoException(LanguageTraslator.traslate("29"));
0749: } else {
0750: ReportManagerLogger.debug(LanguageTraslator.traslate("164")
0751: + ":" + reportSourceDefinition.getId());
0752: getReportSourceRepository().invalidateReportSource(
0753: getReportSpec(reportSourceDefinition));
0754: }
0755: }
0756:
0757: /** Se utiliza para obtener una <Code>ReportQuery</Code> para ser ejecutada al reporte cuyo identidicador que se
0758: * recibe como parámetro, utilizando este método se obtiene una query vacía, donde no hay métricas visibles ni dimensiones
0759: * que agrupan.
0760: * Si se desea ejecutar la query por defecto segun la Definition de Reporte se debe utilizar el método
0761: * <Code>getDefaultReportQuery</Code>
0762: * @param handle
0763: * @return
0764: */
0765:
0766: public ReportQuery getReportQuery(int handle) throws InfoException {
0767: ReportManagerLogger.debug(LanguageTraslator.traslate("165"));
0768: Report report = getReportFrom(handle);
0769: return getReportQuery(report);
0770: }
0771:
0772: /**
0773: * Se utiliza para obtener la <Code>ReportQuery</Code> inicializada con los valores por defecto que figuran en la
0774: * Definición de Reporte
0775: * @param handle
0776: * @return
0777: */
0778: public ReportQuery getDefaultReportQuery(int handle)
0779: throws InfoException {
0780: ReportManagerLogger.debug(LanguageTraslator.traslate("166"));
0781: Report report = getReportFrom(handle);
0782: return getDefaultReportQuery(report);
0783: }
0784:
0785: public ReportQuery getReportQuery(String reportDefinitionId)
0786: throws InfoException {
0787: return new ReportQuery(getReportSpec(reportDefinitionId));
0788: }
0789:
0790: public ReportQuery getDefaultReportQuery(String reportDefinitionId)
0791: throws InfoException {
0792: return new ReportQuery(getReportSpec(reportDefinitionId));
0793: }
0794:
0795: /**
0796: * Se utiliza para obtener la <Code>ReportQuery</Code> por defecto inicializada con los valores por defecto que figuran en la
0797: * Definición de Reporte y sobreescritos por el report view del usuario por defecto
0798: * @param handle
0799: * @return
0800: */
0801: public ReportQuery getDefaultReportQuery(int handle, String userID)
0802: throws InfoException {
0803: ReportManagerLogger.debug(LanguageTraslator.traslate("166"));
0804: Report report = getReportFrom(handle);
0805: return getDefaultReportQuery(report, userID);
0806: }
0807:
0808: /**
0809: * Devuleve la lista de vistas para el usuario y reporte
0810: * @param reportDefinitionID
0811: * @param userID
0812: * @return
0813: * @throws InfoException
0814: */
0815: public Map getReportViews(String reportDefinitionID, String userID)
0816: throws InfoException {
0817: return getReportViewRepository().getAllViewForReportUser(
0818: reportDefinitionID, userID);
0819: }
0820:
0821: /**
0822: * Devuleve la lista de vistas para el reporte
0823: * @param reportDefinitionID
0824: * @return
0825: * @throws InfoException
0826: */
0827: public Map getReportViews(String reportDefinitionID)
0828: throws InfoException {
0829: return getReportViewRepository().getAllViewForDefinition(
0830: reportDefinitionID, this );
0831: }
0832:
0833: public ReportResult ExecReportQuery(int handle, String reportViewId)
0834: throws InfoException {
0835: return ExecReportQuery(handle, getReportView(reportViewId));
0836: }
0837:
0838: public String getDefaultReportViewId(String reportDefinitionId,
0839: String userId) throws InfoException {
0840: ReportView reportView = getDefaultView(reportDefinitionId,
0841: userId);
0842: if (reportView != null) {
0843: return reportView.getId();
0844: }
0845: return null;
0846: }
0847:
0848: public void saveReportView(String reportViewId)
0849: throws InfoException {
0850: saveReportView(getReportView(reportViewId));
0851: }
0852:
0853: public ReportSpec getReportSpec(String reportDefinitionId,
0854: String reportSourceDefId) throws InfoException {
0855: ReportDefinition reportDefinition = getReportDefinitionFromID(reportDefinitionId);
0856: ReportSourceDefinition reportSourceDefinition = getReportSourceDefinitionFromID(reportSourceDefId);
0857: return getReportSpec(reportDefinition, reportSourceDefinition);
0858: }
0859:
0860: public ReportSpec getReportSpec(String reportDefinitionId)
0861: throws InfoException {
0862: ReportDefinition reportDefinition = getReportDefinitionFromID(reportDefinitionId);
0863: ReportSourceDefinition reportSourceDefinition = getReportSourceDefinitionFromID(reportDefinition
0864: .getReportSource());
0865: return getReportSpec(reportDefinition, reportSourceDefinition);
0866: }
0867:
0868: public ReportView getReportView(String reportViewId)
0869: throws InfoException {
0870: return null;
0871: }
0872:
0873: /**
0874: *
0875: * @param handle
0876: * @param reportView
0877: * @return
0878: * @throws InfoException
0879: */
0880: public ReportResult ExecReportQuery(int handle,
0881: ReportView reportView) throws InfoException {
0882: ReportManagerLogger.debug(LanguageTraslator.traslate("167")
0883: + ":"
0884: + ((reportView != null) ? reportView.getId() : ""));
0885: Report report = getReportFrom(handle);
0886: ReportQuery reportQuery = new ReportQuery(report
0887: .getReportSpec(), reportView);
0888: return ExecReportQuery(report, reportQuery);
0889: }
0890:
0891: public ReportView getReportViewFromID(String id,
0892: String reportDefinitionId, String userId)
0893: throws InfoException {
0894: ReportManagerLogger.debug(LanguageTraslator.traslate("168")
0895: + ":" + id);
0896: return getReportViewRepository().loadFromID(id,
0897: reportDefinitionId, userId);
0898: }
0899:
0900: /**
0901: * Graba un report view
0902: * @param reportView
0903: * @throws InfoException
0904: */
0905: public void saveReportView(ReportView reportView)
0906: throws InfoException {
0907: ReportManagerLogger.debug(LanguageTraslator.traslate("169")
0908: + ":" + reportView.getId());
0909: getReportViewRepository().save(reportView);
0910: }
0911:
0912: /** Se utiliza para obtener una <Code>ReportQuery</Code> para ser ejecutada al reporte a pertir de una definición de
0913: * reporte, utilizando este método se obtiene una query vacía, donde no hay métricas visibles ni dimensiones que agrupan.
0914: * Si se desea ejecutar la query por defecto segun la Definition de Reporte se debe utilizar el método
0915: * <Code>getDefaultReportQuery</Code>
0916: * @param reportDefinition
0917: * @return
0918: * @throws InfoException Si no se pudo obtener el ReportQuery
0919: */
0920:
0921: public ReportQuery getReportQuery(ReportDefinition reportDefinition)
0922: throws InfoException {
0923: if (reportDefinition == null) {
0924: throw new InfoException(LanguageTraslator.traslate("30"));
0925: } else {
0926: ReportManagerLogger.debug(LanguageTraslator.traslate("165")
0927: + ":" + reportDefinition.getId());
0928: ReportQuery query = new ReportQuery(
0929: getReportSpec(reportDefinition), false);
0930: return query;
0931: }
0932: }
0933:
0934: /**
0935: * Se utiliza para obtener la <Code>ReportQuery</Code> inicializada con los valores por defecto que figuran en la
0936: * Definición de Reporte
0937: * @param reportDefinition
0938: * @return
0939: * @throws InfoException Si no se puede obtener la query por defecto.
0940: */
0941: public ReportQuery getDefaultReportQuery(
0942: ReportDefinition reportDefinition) throws InfoException {
0943: if (reportDefinition == null) {
0944: throw new InfoException(LanguageTraslator.traslate("31"));
0945: } else {
0946: ReportQuery query = new ReportQuery(
0947: getReportSpec(reportDefinition));
0948: return query;
0949: }
0950: }
0951:
0952: /** Se utiliza para obtener una <Code>ReportQuery</Code> para ser ejecutada al reporte que se recibe como parámetro,
0953: * utilizando este método se obtiene una query vacía, donde no hay métricas visibles ni dimensiones que agrupan.
0954: * Si se desea ejecutar la query por defecto segun la Definition de Reporte se debe utilizar el método
0955: * <Code>getDefaultReportQuery</Code>
0956: * @param report
0957: * @return
0958: * @throws InfoException
0959: */
0960: protected ReportQuery getReportQuery(Report report)
0961: throws InfoException {
0962: if (report == null) {
0963: throw new InfoException(LanguageTraslator.traslate("32"));
0964: } else {
0965: return report.getQuery();
0966: }
0967: }
0968:
0969: /**
0970: * Se utiliza para obtener la <Code>ReportQuery</Code> inicializada con los valores por defecto que figuran en la
0971: * Definición de Reporte
0972: * @param report
0973: * @return
0974: * @throws InfoException
0975: */
0976: protected ReportQuery getDefaultReportQuery(Report report)
0977: throws InfoException {
0978: if (report == null) {
0979: throw new InfoException(LanguageTraslator.traslate("33"));
0980: } else {
0981: return report.getDefaultQuery();
0982: }
0983: }
0984:
0985: /**
0986: * Se utiliza para obtener la <Code>ReportQuery</Code> inicializada con los valores por defecto que figuran en la
0987: * Definición de Reporte y los del la vista por defecto del usuario
0988: * @param report
0989: * @return
0990: * @throws InfoException
0991: */
0992: protected ReportQuery getDefaultReportQuery(Report report,
0993: String userID) throws InfoException {
0994: if (report == null) {
0995: throw new InfoException(LanguageTraslator.traslate("34"));
0996: } else {
0997: return report.getDefaultQuery(getDefaultView(report
0998: .getReportSpec().getDefinitionId(), userID));
0999: }
1000: }
1001:
1002: /**
1003: * Obtiene la vista por defecto para el usuario
1004: */
1005: protected ReportView getDefaultView(String reportDefinitionID,
1006: String userID) throws InfoException {
1007: return getReportViewRepository().getDefaultViewForReportUser(
1008: reportDefinitionID, userID);
1009:
1010: }
1011:
1012: /** Ejecuta la query, o vista, por Default de un reporte a partir del identificador
1013: * de la instancia de reporte obtenido del método <code>PrepareReport</code>
1014: * paramValues es un diccionario cuyas entradas contienen en la clave el nombre del parámetro y cuyos objetos asociados
1015: * contienen los valores de los parámetros
1016: * Nota: la clave de los parámetros se compone concatenando el nombre de la definición filtro y el nombre del
1017: * parámetro del filtro.
1018: * Ejemplo 1:
1019: * Definición de filtro: RANGO_CLIENTE (tipo RANGE)-> determina dos parámetros(claves): RANGO_CLIENTEFROM y RANGO_CLIENTETO
1020: * (el filtro de tipo RANGE tiene dos parámetros, FROM y TO)
1021: * Ejemplo 2:
1022: * Definicion de filtro: DESDE_CLIENTE (tipo GREATERTHAN) -> determina un parámetro(clave): DESDE_CLIENTEVALUE
1023: * (el filtro de tipo GREATERTHAN tiene un parámetro, VALUE)
1024: * @param handle identificador del reporte preparado
1025: * @param paramValues valores de parámetros
1026: * @return devuelve la información resultante de la ejecución de la query
1027: */
1028:
1029: public ReportResult ExecReportQuery(int handle, Map paramValues)
1030: throws InfoException {
1031: Report report = getReportFrom(handle);
1032: return ExecReportQuery(report, paramValues);
1033: }
1034:
1035: /** Ejecuta una query, o vista, de un reporte a partir del identificador
1036: * de la instancia de reporte obtenido del método <code>PrepareReport</code>
1037: * @param handle identificador del reporte preparado
1038: * @param query es una estructura de datos que especifica las dimensiones que se desea visualizar,
1039: * en que orden, su ubicación y las métricas deseadas.
1040: * @return devuelve la información resultante de la ejecución de la query
1041: */
1042:
1043: public ReportResult ExecReportQuery(int handle, ReportQuery query)
1044: throws InfoException {
1045: Report report = getReportFrom(handle);
1046: return ExecReportQuery(report, query);
1047: }
1048:
1049: /** Ejecuta la query, o vista, por Default de un reporte a partir de una instancia de Reporte
1050: * creada en base una definición
1051: * de la instancia de reporte obtenido del método <code>PrepareReport</code>
1052: * @param report
1053: * @param paramValues
1054: * @return
1055: * @throws InfoException
1056: */
1057:
1058: protected ReportResult ExecReportQuery(Report report,
1059: Map paramValues) throws InfoException {
1060: if (report == null) {
1061: throw new InfoException(LanguageTraslator.traslate("35"));
1062: } else {
1063: ReportManagerLogger
1064: .debug(LanguageTraslator.traslate("172"));
1065: return report.ExecQuery(paramValues);
1066: }
1067: }
1068:
1069: /**Ejecuta una query, o vista, de un reporte a partir del una instancia de Reporte
1070: * creada en base una definición
1071: * @param report
1072: * @param query
1073: * @return
1074: * @throws InfoException
1075: */
1076: protected ReportResult ExecReportQuery(Report report,
1077: ReportQuery query) throws InfoException {
1078: return report.ExecQuery(query);
1079: }
1080:
1081: /** Ejecuta la query, o vista, por Default de un reporte a partir un identificador de definición de reporte
1082: * Esta version del método se utiliza para ejecutar un reporte al que no se le ejecutarán nuevas
1083: * querys y acciones. Para esto no hace falta llamar a <code>PrepareReport</code>
1084: * @param reportDefinitionID definición de reporte
1085: * @param paramValues valores de parámetros
1086: * @return devuelve la información resultante de la ejecución de la query
1087: * @throws InfoException
1088: */
1089:
1090: public ReportResult ExecReportQuery(String reportDefinitionID,
1091: Map paramValues) throws InfoException {
1092: if (reportDefinitionID.equals("")) {
1093: throw new InfoException(LanguageTraslator.traslate("36"));
1094: } else {
1095: return ExecReportQuery(
1096: getReportDefinitionFromID(reportDefinitionID),
1097: paramValues);
1098: }
1099: }
1100:
1101: /** Ejecuta una query, o vista, de un reporte a partir un identificador de definición de reporte
1102: * Esta version del método se utiliza para ejecutar un reporte al que no se le ejecutarán nuevas
1103: * querys y acciones. Para esto no es necesario llamar a <code>PrepareReport</code>
1104: * @param reportDefinitionID definición de reporte
1105: * @param query es una estructura de datos que especifica las dimensiones que se desea visualizar,
1106: * en que orden, su ubicación y las métricas deseadas.
1107: * @return devuelve la información resultante de la ejecución de la query
1108: */
1109:
1110: public ReportResult ExecReportQuery(String reportDefinitionID,
1111: ReportQuery query) throws InfoException {
1112: return ExecReportQuery(
1113: getReportDefinitionFromID(reportDefinitionID), query);
1114: }
1115:
1116: /** Ejecuta la query, o vista, por Default de un reporte a partir una definición de reporte
1117: * Esta versión del método se utiliza para ejecutar un reporte al que no se le ejecutarán nuevas
1118: * querys y acciones. Para esto no hace falta llamar a <code>PrepareReport</code>
1119: * @param reportDef definición de reporte
1120: * @return devuelve la información resultante de la ejecución de la query
1121: * @throws InfoException
1122: */
1123: public ReportResult ExecReportQuery(ReportDefinition reportDef,
1124: Map paramValues) throws InfoException {
1125: Report report = null;
1126: if (reportDef == null) {
1127: throw new InfoException(LanguageTraslator.traslate("37"));
1128: } else {
1129: try {
1130: report = newReportFrom(reportDef, paramValues);
1131: } catch (InfoException e) {
1132: throw new InfoException(LanguageTraslator
1133: .traslate("38")
1134: + ":" + reportDef.getId(), e);
1135: }
1136: if (report != null) {
1137: return ExecReportQuery(report, paramValues);
1138: }
1139: throw new InfoException(LanguageTraslator.traslate("39")
1140: + ":" + reportDef.getId());
1141: }
1142: }
1143:
1144: /** Ejecuta una query, o vista, de un reporte a partir una definición de reporte
1145: * Esta versión del método se utiliza para ejecutar un reporte al que no se le ejecutarán nuevas
1146: * querys y acciones. Para esto no es necesario llamar a <code>PrepareReport</code>
1147: * @param reportDef definición de reporte
1148: * @param query es una estructura de datos que especifica las dimensiones que se desea visualizar,
1149: * en que orden, su ubicación y las métricas deseadas.
1150: * @return devuelve la información resultante de la ejecución de la query
1151: */
1152:
1153: public ReportResult ExecReportQuery(ReportDefinition reportDef,
1154: ReportQuery query) throws InfoException {
1155: Report report = null;
1156: if (reportDef == null) {
1157: throw new InfoException(LanguageTraslator.traslate("40"));
1158: } else {
1159: report = newReportFrom(reportDef);
1160: if (report != null) {
1161: return ExecReportQuery(report, query);
1162: }
1163: throw new InfoException(LanguageTraslator.traslate("41")
1164: + ":" + reportDef.getId());
1165: }
1166: }
1167:
1168: /** Inicializa la ejecución de reporte para una aplicación cliente, este método debe utilizarse para preparar reportes
1169: * cacheados, en este tipo de reporte los valores de los parámetros de los pre-filtros no pueden ser modificados por el
1170: * usuario y se utilizan los que figuran en la definición
1171: * @param reportDefinitionID identificador de definición de reporte
1172: * @return devuelve un identificador de la instancia del reporte en la sesión,
1173: * que se debe utilizar para sucesivas operaciones.
1174: * @throws InfoException Si no se pudo ejecutar el prepare
1175: */
1176: public int PrepareReport(String reportDefinitionID)
1177: throws InfoException {
1178: ReportDefinition reportDefinition = getReportDefinitionFromID(reportDefinitionID);
1179: return PrepareReport(reportDefinition);
1180: }
1181:
1182: public int PrepareReport(String reportDefinitionId, Map paramValues)
1183: throws InfoException {
1184: return PrepareReport(
1185: getReportDefinitionFromID(reportDefinitionId),
1186: paramValues);
1187: }
1188:
1189: /**
1190: * Devuelve el log
1191: * @return
1192: */
1193: public Log getLogger() {
1194: return ReportManagerLogger.getLog();
1195: }
1196:
1197: /**
1198: * Asigna el log
1199: * @param log
1200: */
1201: public void setLogger(Log log) {
1202: ReportManagerLogger.setLog(log);
1203: }
1204:
1205: /**
1206: * Registra las definiciones disponibles en el directorio de sources files
1207: * @throws InfoException
1208: */
1209: public void registerDefinitions() throws InfoException {
1210: registerReportDefinitions(new Vector());
1211: registerReportSourceDefinitions(new Vector());
1212: registerReportViews(new Vector());
1213: }
1214:
1215: /**
1216: * Borra todos los repositorios
1217: * @throws InfoException
1218: */
1219: public void deleteAllRepositories() throws InfoException {
1220: getReportDefinitionRepository().deleteAll();
1221: getReportSourceRepository().deleteAll();
1222: getReportSourceDefinitionRepository().deleteAll();
1223: getReportViewRepository().getCache().deleteAll();
1224: //getReportViewRepository().deleteAll();
1225: };
1226:
1227: /**
1228: * Borra del repositorio todas las definiciones menos los cache
1229: * @throws InfoException
1230: */
1231: public void deleteAllDefinitions() throws InfoException {
1232: getReportDefinitionRepository().deleteAll();
1233: getReportSourceDefinitionRepository().deleteAll();
1234: getReportViewRepository().getCache().deleteAll();
1235: //getReportViewRepository().deleteAll();
1236: };
1237:
1238: /**
1239: * Borra del depositorio todos los report source
1240: * @throws InfoException
1241: */
1242: public void deleteReportSourceRepository() throws InfoException {
1243: getReportSourceRepository().deleteAll();
1244: };
1245:
1246: /**
1247: * Borra del repositorio todas las report source definition
1248: * @throws InfoException
1249: */
1250: public void deleteReportSourceDefinitionRepository()
1251: throws InfoException {
1252: getReportSourceRepository().deleteAll();
1253: };
1254:
1255: /**
1256: * Borra del repositorio todas las report definition
1257: * @throws InfoException
1258: */
1259: public void deleteReportDefinitionRepository() throws InfoException {
1260: getReportDefinitionRepository().deleteAll();
1261: };
1262:
1263: /**
1264: * Borra del repositorio todas las report views
1265: * @throws InfoException
1266: */
1267: public void deleteReportViewRepository() throws InfoException {
1268: getReportViewRepository().deleteAll();
1269: };
1270:
1271: /**
1272: * Borra el report view
1273: * @param id
1274: * @param reportDefinitionId
1275: * @param userId
1276: * @throws InfoException
1277: */
1278: public void deleteReportView(String id, String reportDefinitionId,
1279: String userId) throws InfoException {
1280: getReportViewRepository()
1281: .delete(id, reportDefinitionId, userId);
1282: }
1283:
1284: public void deleteReportSource(String reportSourceDefinitionId)
1285: throws InfoException {
1286: };
1287:
1288: /**
1289: * Borra el report source
1290: * @param reportSourceDefinition
1291: * @throws InfoException
1292: */
1293: public void deleteReportSource(
1294: ReportSourceDefinition reportSourceDefinition)
1295: throws InfoException {
1296: getReportSourceRepository().deleteReportSource(
1297: getReportSpec(reportSourceDefinition));
1298: };
1299:
1300: /**
1301: * Borra el report source definition
1302: * @param reportSourceDefinitionID
1303: * @throws InfoException
1304: */
1305: public void deleteReportSourceDefinition(
1306: String reportSourceDefinitionID) throws InfoException {
1307: getReportSourceDefinitionRepository().delete(
1308: reportSourceDefinitionID);
1309: };
1310:
1311: /**
1312: * Borra el report definition
1313: * @param reportDefinitionID
1314: * @throws InfoException
1315: */
1316: public void deleteReportDefinition(String reportDefinitionID)
1317: throws InfoException {
1318: getReportDefinitionRepository().delete(reportDefinitionID);
1319: };
1320:
1321: /**
1322: * Asigna el la vista por defecto para el usuario
1323: * @param id
1324: * @param reportDefinitionId
1325: * @param userId
1326: * @throws InfoException
1327: */
1328: public void assingDefaultView(String id, String reportDefinitionId,
1329: String userId) throws InfoException {
1330: getReportViewRepository().assingDefaultView(id,
1331: reportDefinitionId, userId);
1332: };
1333:
1334: /**
1335: * Registra los reportdefinitions que esten en el path
1336: */
1337: public Vector registerReportDefinitions(Vector exceptions)
1338: throws InfoException {
1339: try {
1340: FileSystemManager fileSystemManager = FileSystemResolver
1341: .getFileSystemManager(getReportGeneratorConfiguration());
1342: FileObject fileObject = fileSystemManager
1343: .resolveFile(getReportGeneratorConfiguration()
1344: .getSourceReportDefinitionsPath());
1345: String fileName;
1346: for (int i = 0; i < fileObject.getChildren().length; i++) {
1347: fileName = fileObject.getChildren()[i].getName()
1348: .getBaseName();
1349: if (!fileName.endsWith(".xml")) {
1350: continue;
1351: }
1352: ReportManagerLogger.debug(LanguageTraslator
1353: .traslate("276")
1354: + ":" + fileName);
1355: try {
1356: saveReportDefinition((ReportDefinition) Unmarshaller
1357: .unmarshal(
1358: ReportDefinition.class,
1359: new FileReader(
1360: getReportGeneratorConfiguration()
1361: .getSourceReportDefinitionsPath()
1362: + "/" + fileName)));
1363: } catch (Exception e) {
1364: exceptions.add(e);
1365: }
1366: }
1367: } catch (Exception e) {
1368: throw new InfoException(LanguageTraslator.traslate("210"),
1369: e);
1370: }
1371: return exceptions;
1372: }
1373:
1374: /**
1375: * Registra los reportsourcedefinitions que esten en el path
1376: */
1377: public Vector registerReportSourceDefinitions(Vector exceptions)
1378: throws InfoException {
1379: try {
1380: FileSystemManager fileSystemManager = FileSystemResolver
1381: .getFileSystemManager(getReportGeneratorConfiguration());
1382: FileObject fileObject = fileSystemManager
1383: .resolveFile(getReportGeneratorConfiguration()
1384: .getSourceReportSourceDefinitionsPath());
1385: String fileName;
1386: for (int i = 0; i < fileObject.getChildren().length; i++) {
1387: fileName = fileObject.getChildren()[i].getName()
1388: .getBaseName();
1389: if (!fileName.endsWith(".xml")) {
1390: continue;
1391: }
1392: ReportManagerLogger.debug(LanguageTraslator
1393: .traslate("275")
1394: + ":" + fileName);
1395: try {
1396: ReportSourceDefinitionVersion
1397: .validateVersion(fileObject.getChildren()[i]);
1398: saveReportSourceDefinition((ReportSourceDefinition) Unmarshaller
1399: .unmarshal(
1400: ReportSourceDefinition.class,
1401: new FileReader(
1402: getReportGeneratorConfiguration()
1403: .getSourceReportSourceDefinitionsPath()
1404: + "/" + fileName)));
1405: } catch (Exception e) {
1406: exceptions.add(e);
1407: }
1408: }
1409: } catch (Exception e) {
1410: throw new InfoException(LanguageTraslator.traslate("209"),
1411: e);
1412: }
1413: return exceptions;
1414: }
1415:
1416: /**
1417: * Registra los reportviews que esten en el path
1418: */
1419: public Vector registerReportViews(Vector exceptions)
1420: throws InfoException {
1421: try {
1422: FileSystemManager fileSystemManager = FileSystemResolver
1423: .getFileSystemManager(getReportGeneratorConfiguration());
1424: FileObject fileObject = fileSystemManager
1425: .resolveFile(getReportGeneratorConfiguration()
1426: .getSourceReportViewsPath());
1427: String fileName;
1428: for (int i = 0; i < fileObject.getChildren().length; i++) {
1429: fileName = fileObject.getChildren()[i].getName()
1430: .getBaseName();
1431: if (!fileName.endsWith(".xml")) {
1432: continue;
1433: }
1434: ReportManagerLogger.debug(LanguageTraslator
1435: .traslate("277")
1436: + ":" + fileName);
1437: try {
1438: saveReportView((ReportView) Unmarshaller.unmarshal(
1439: ReportView.class, new FileReader(
1440: getReportGeneratorConfiguration()
1441: .getSourceReportViewsPath()
1442: + "/" + fileName)));
1443: } catch (Exception e) {
1444: exceptions.add(e);
1445: }
1446: }
1447: return exceptions;
1448: } catch (Exception e) {
1449: throw new InfoException(LanguageTraslator.traslate("252"),
1450: e);
1451: }
1452: }
1453:
1454: public ReportGeneratorConfiguration getReportGeneratorConfiguration() {
1455: return reportGeneratorConfiguration;
1456: }
1457:
1458: /**
1459: * Devuelve el reportview por defecto para el usuario
1460: * @param reportDefinitionId
1461: * @param userId
1462: * @return
1463: * @throws InfoException
1464: */
1465: public ReportView getDefaultReportView(String reportDefinitionId,
1466: String userId) throws InfoException {
1467: return getReportViewRepository().getDefaultViewForReportUser(
1468: reportDefinitionId, userId);
1469: };
1470:
1471: /**
1472: * Ejecuta un reporte Para un Micro report
1473: * @param microReport
1474: * @return
1475: * @throws InfoException
1476: */
1477: public ReportResult ExecReportQuery(MicroReport microReport)
1478: throws InfoException {
1479: Map map = new HashMap();
1480: return this .ExecReportQuery(microReport.getReportDefinition()
1481: .getId(), map);
1482: }
1483:
1484: /**
1485: * Inicializa la ejecución de un reporte a partir de un Micro Report
1486: * @param microReport
1487: * @return
1488: * @throws InfoException
1489: */
1490: public int PrepareReport(MicroReport microReport)
1491: throws InfoException {
1492: Report report = null;
1493: if (microReport.getReportDefinition() == null) {
1494: throw new InfoException(LanguageTraslator.traslate("12"));
1495: } else {
1496: ReportManagerLogger.debug(LanguageTraslator.traslate("196")
1497: + ":" + microReport.getReportDefinition().getId());
1498: ReportSpec reportSpec = getReportSpec(microReport
1499: .getReportDefinition(), microReport
1500: .getReportSourceDefinition());
1501: ReportSource reportSource = new ReportSource(reportSpec,
1502: microReport.getMatrix(),
1503: reportGeneratorConfiguration);
1504: if ((reportSpec.getReportType().toString()
1505: .equalsIgnoreCase(ReportDefinitionReportTypeType.CUBE
1506: .toString()))
1507: || (reportSpec.getReportType().toString()
1508: .equalsIgnoreCase(ReportDefinitionReportTypeType.CHARTCUBE
1509: .toString()))) {
1510: report = new CubeReport(reportSpec, reportSource,
1511: reportGeneratorConfiguration);
1512: } else if (reportSpec.getReportType().toString()
1513: .equalsIgnoreCase(
1514: ReportDefinitionReportTypeType.ACCUM
1515: .toString())) {
1516: report = new StaticReport(reportSpec, reportSource,
1517: reportGeneratorConfiguration);
1518: }
1519: if (report != null) {
1520: int handle = registerReport(report);
1521: return handle;
1522: }
1523: }
1524: return 0;
1525: }
1526:
1527: /**
1528: * Retorna un MicroReport zip
1529: * @param reportHandle
1530: * @param reportView
1531: * @param userID
1532: * @param fileName
1533: * @return
1534: * @throws InfoException
1535: */
1536: /* public ZipOutputStream getMicroReport(int reportHandle, ReportView reportView,String userID,String fileName) throws InfoException {
1537: try {
1538: ReportDefinition reportDefinition = getReportDefinitionFromID(reportView.getReportDefinitionId());
1539: ReportSourceDefinition reportSourceDefinition = getReportSourceDefinitionFromID(reportDefinition.getReportSource());
1540: MicroReport microReport = new MicroReport(getReportFrom(reportHandle).getPivot().getMatrix(),reportSourceDefinition,reportDefinition,reportView,"",userID,getReportViews(reportDefinition.getId(),userID));
1541: return microReport.getZip(fileName);
1542: }catch(Exception e){
1543: throw new InfoException(LanguageTraslator.traslate("12"));
1544: }
1545: }
1546: */
1547: /**
1548: * Retorna la matris para un handle
1549: * @param handle
1550: * @return
1551: * @throws InfoException
1552: */
1553: public Matrix getMatrix(int handle) throws InfoException {
1554: return getReportFrom(handle).getPivot().getMatrix();
1555: }
1556:
1557: public String getXML(int handle) throws InfoException {
1558: return getReportFrom(handle).getXml();
1559: }
1560:
1561: public String getXML(String reportDefinitionID, Map paramValues)
1562: throws InfoException {
1563: int handle = PrepareReport(
1564: getReportDefinitionFromID(reportDefinitionID),
1565: paramValues);
1566: return getXML(handle);
1567: }
1568:
1569: public Set getDimensionValues(int handle, String name)
1570: throws InfoException {
1571: return getReportFrom(handle).getDimensionValues(name);
1572: }
1573:
1574: public Set getDimensionValues(String reportDefinitionID,
1575: Map paramValues, String name) throws InfoException {
1576: int handle = PrepareReport(
1577: getReportDefinitionFromID(reportDefinitionID),
1578: paramValues);
1579: return getDimensionValues(handle, name);
1580: }
1581:
1582: public Vector getUpdatedDataModel(int handle, int mode, int row,
1583: int col, boolean isDistributed) throws InfoException {
1584: return ((CubeReport) getReportFrom(handle))
1585: .getUpdatedDataModel(mode, row, col, isDistributed);
1586: }
1587:
1588: /**
1589: * Valida un usuario
1590: * @param userName Nombre del usuario
1591: * @param password Password del usuario
1592: * @param userRepositoryPath Localizacion del repositorio en el sistema
1593: * @return indica si la validacion ha sido satisfactoria
1594: * @throws InfoException
1595: */
1596: public boolean validateUser(String userName, String password,
1597: String userRepositoryPath) throws InfoException {
1598: boolean authenticated = false;
1599: UsersRepository repository = new UsersRepository(
1600: userRepositoryPath);
1601: File file = new File(userRepositoryPath);
1602: if (file.exists()) {
1603: authenticated = repository.validate(userName, password);
1604: } else {
1605: repository.addNewUser("root", password);
1606: authenticated = true;
1607: }
1608: return authenticated;
1609: }
1610:
1611: public boolean validateRol(String[] roles, String userName,
1612: String rolRepositoryPath) throws InfoException {
1613: boolean authenticated = false;
1614: RolsRepository repository = new RolsRepository(
1615: rolRepositoryPath);
1616: File file = new File(rolRepositoryPath);
1617: if (file.exists()) {
1618: int index = 0;
1619: while (index < roles.length && !authenticated) {
1620: authenticated = repository.validateRol(userName,
1621: roles[index]);
1622: index++;
1623: }
1624: }
1625: return authenticated;
1626: }
1627:
1628: public void exportReport(String userName, String password,
1629: String userRepositoryPath, String reportDefinitionId,
1630: Map paramValues, boolean isLandscape, int type,
1631: String destinationPath, String name) throws InfoException {
1632: if (validateUser(userName, password, userRepositoryPath)) {
1633: try {
1634: ReportDefinition reportDefinition = getReportDefinitionFromID(reportDefinitionId);
1635: ReportSourceDefinition reportSource = getReportSourceDefinitionFromID(reportDefinition
1636: .getReportSource());
1637: ReportSpec reportSpec = getReportSpec(reportDefinition,
1638: reportSource);
1639: ReportResult reportResult = null;
1640: if (!(reportDefinition.getReportType() == ReportDefinitionReportTypeType.STATICSQL)) {
1641: reportResult = ExecReportQuery(reportDefinition,
1642: paramValues);
1643: }
1644: ReportLayoutBuilder builder = new ReportLayoutBuilder(
1645: getReportGeneratorConfiguration(), reportSpec,
1646: reportResult, paramValues);
1647: JasperPrint print = builder.getJasperPrint(isLandscape);
1648: exportReport(print, (destinationPath + name), type);
1649: System.out.println(LanguageTraslator.traslate("533"));
1650: } catch (Exception e) {
1651: throw new InfoException(LanguageTraslator
1652: .traslate("312"), e);
1653: }
1654: } else {
1655: throw new InfoException(LanguageTraslator.traslate("295"));
1656: }
1657: }
1658:
1659: public byte[] exportReport(Map params) throws InfoException {
1660: try {
1661: String reportDefinitionId = (String) params
1662: .get("ReportDefinitionId");
1663: String reportViewId = (String) params.get("ReportViewId");
1664: String userId = (String) params.get("UserId");
1665: ReportDefinition definition;
1666: ReportView view = null;
1667: if (reportViewId != null
1668: && !reportViewId.toString().equalsIgnoreCase("")
1669: && userId != null && reportDefinitionId != null) {
1670: view = getReportViewFromID(reportViewId,
1671: reportDefinitionId, userId);
1672: definition = getReportDefinitionFromID(view
1673: .getReportDefinitionId());
1674: } else if (reportDefinitionId != null
1675: && !reportDefinitionId.toString().equalsIgnoreCase(
1676: "")) {
1677: definition = getReportDefinitionFromID(reportDefinitionId
1678: .toString());
1679: } else {
1680: throw new InfoException(LanguageTraslator.traslate("2"));
1681: }
1682: ReportSpec spec = getReportSpec(definition);
1683: ReportResult result = null;
1684: if (definition.getReportType() != ReportDefinitionReportTypeType.STATICSQL) {
1685: int handle = PrepareReport(definition, params);
1686: if (view != null) {
1687: result = ExecReportQuery(handle, view);
1688: } else {
1689: result = ExecReportQuery(handle, params);
1690: }
1691: }
1692: ReportLayoutBuilder builder = new ReportLayoutBuilder(
1693: getReportGeneratorConfiguration(), spec, result,
1694: params);
1695: boolean isLandscape = true;
1696: if (params.get("IsLandscape") != null) {
1697: if (params.get("IsLandscape").toString()
1698: .equalsIgnoreCase("false")) {
1699: isLandscape = false;
1700: }
1701: }
1702: JasperPrint print = builder.getJasperPrint(isLandscape);
1703: return JasperExportManager.exportReportToPdf(print);
1704: } catch (Exception e) {
1705: throw new InfoException(LanguageTraslator.traslate("311"),
1706: e);
1707: }
1708: }
1709:
1710: /* private JasperPrint getJasperPrint(ReportDefinition reportDefinition, Map paramValues, boolean isLandscape) throws InfoException{
1711: try{
1712: ReportResult reportResult = ExecReportQuery(reportDefinition,paramValues);
1713: com.calipso.reportgenerator.common.ReportTableModel reportTableModel = reportResult.getReportTableModel();
1714: IJasperDefinition jasperDefinition = getJasperDefinition(reportResult, reportTableModel, reportDefinition.getTitle());
1715: JasperReport report = JasperCompileManager.compileReport(jasperDefinition.getJasperDefinition(isLandscape));
1716: ReportMap.setParametersToSimpleType(paramValues);
1717: return JasperFillManager.fillReport(report, paramValues, reportTableModel);
1718: }catch (Exception e){
1719: throw new InfoException(LanguageTraslator.traslate("312"), e);
1720: }
1721: }
1722:
1723: public JasperPrint getJasperPrintFromSql(ReportDefinition reportDefinition, Map paramValues, boolean isLandscape) throws InfoException {
1724: try {
1725: if(!(paramValues instanceof HashMap)){
1726: paramValues = new HashMap();
1727: }
1728: ReportSourceDefinition reportSource = getReportSourceDefinitionFromID(reportDefinition.getReportSource());
1729: ReportSpec reportSpec = getReportSpec(reportDefinition, reportSource);
1730: ReportQuery query = new ReportQuery(reportSpec);
1731: com.calipso.reportgenerator.common.ReportTableModel reportTableModel = getStaticNonDataTableModel(reportSpec, query);
1732: ReportDataSourceSpec dataSourceSpec = (ReportDataSourceSpec)reportSpec.getDataSourceSpecs().toArray()[0];
1733: Connection con = getConnection(dataSourceSpec, reportSpec);
1734: IJasperDefinition jasperDefinition = getSQLJasperDefinition(reportSpec, reportTableModel, reportDefinition.getTitle(), isLandscape);
1735: ((StaticSQLJasperReportDefinition)jasperDefinition).setSQLText(dataSourceSpec.getExpression());
1736: JasperReport report = JasperCompileManager.compileReport(jasperDefinition.getJasperDefinition(isLandscape));
1737: return JasperFillManager.fillReport(report, paramValues, con);
1738: }catch(Exception e){
1739: throw new InfoException(LanguageTraslator.traslate("312"), e);
1740: }
1741: }
1742:
1743: private Connection getConnection(ReportDataSourceSpec dataSourceSpec, ReportSpec reportSpec) throws InfoException{
1744: DataSourceDefinitionConnectionString dataSourceDefinitionConnectionString = new DataSourceDefinitionConnectionString(dataSourceSpec.getExternalConnectionValues());
1745: try {
1746: Class.forName(dataSourceDefinitionConnectionString.getValue("DatabaseConfigurationClassName"));
1747: return DriverManager.getConnection(dataSourceDefinitionConnectionString.getValue("DatabaseConfigurationLocalUrl"), dataSourceDefinitionConnectionString.getValue("DatabaseConfigurationUser"), dataSourceDefinitionConnectionString.getValue("DatabaseConfigurationPassword"));
1748: } catch (Exception e) {
1749: throw new InfoException(LanguageTraslator.traslate("97"), e);
1750: }
1751: }
1752:
1753: private com.calipso.reportgenerator.common.ReportTableModel getStaticNonDataTableModel(ReportSpec reportSpec, ReportQuery query) {
1754: return new StaticReportTableModel(reportSpec, query);
1755: }
1756:
1757: private IJasperDefinition getSQLJasperDefinition(ReportSpec reportSpec, com.calipso.reportgenerator.common.ReportTableModel reportTableModel, String tittle, boolean isLandscape) throws InfoException{
1758: if ((reportSpec.getLayoutDesign()==null) || reportSpec.getLayoutDesign().equals("")) {
1759: return new StaticSQLJasperReportDefinition(reportSpec, reportTableModel.getModel(), reportTableModel.getGroupingDimCount(), reportTableModel.getCommonMetricsCount(),
1760: reportTableModel.getNonGroupingDimCount(), reportTableModel.getAccMetricsCount(), tittle, params);
1761: }else{
1762: String layoutName = reportSpec.getLayoutDesign().endsWith(".xml") ? reportSpec.getLayoutDesign() : reportSpec.getLayoutDesign() + ".xml";
1763: IJasperDefinition jasper = new ExternalJasperDefinition(getReportGeneratorConfiguration().getSourceReportLayoutPath() + "/" + layoutName);
1764: return setSQLJasperDefinition(jasper, isLandscape);
1765: }
1766: }
1767:
1768: private IJasperDefinition setSQLJasperDefinition(IJasperDefinition jasper, boolean isLandscape) throws InfoException{
1769: return new StaticSQLJasperReportDefinition(jasper, isLandscape);
1770: }*/
1771:
1772: private void exportReport(JasperPrint print, String destFile,
1773: int type) throws JRException, InfoException {
1774: switch (type) {
1775: case ReportExportFormatType.PDF_TYPE:
1776: JasperExportManager.exportReportToPdfFile(print, destFile);
1777: break;
1778: case ReportExportFormatType.XML_TYPE:
1779: JasperExportManager.exportReportToXmlFile(print, destFile,
1780: false);
1781: break;
1782: case ReportExportFormatType.HTML_TYPE:
1783: JasperExportManager.exportReportToHtmlFile(print, destFile);
1784: break;
1785: case ReportExportFormatType.EXCEL_TYPE:
1786: JRXlsExporter xlsExporter = new JRXlsExporter();
1787: xlsExporter.setParameter(JRExporterParameter.JASPER_PRINT,
1788: print);
1789: xlsExporter.setParameter(
1790: JRExporterParameter.OUTPUT_FILE_NAME, destFile);
1791: xlsExporter.exportReport();
1792: break;
1793: case ReportExportFormatType.COMMA_TYPE:
1794: JRCsvExporter CsvExporter = new JRCsvExporter();
1795: CsvExporter.setParameter(JRExporterParameter.JASPER_PRINT,
1796: print);
1797: CsvExporter.setParameter(
1798: JRExporterParameter.OUTPUT_FILE_NAME, destFile);
1799: CsvExporter.exportReport();
1800: break;
1801: default:
1802: throw new InfoException("312");
1803: }
1804: }
1805:
1806: /*private IJasperDefinition getJasperDefinition(ReportResult reportResult, com.calipso.reportgenerator.common.ReportTableModel reportTableModel, String tittle) throws InfoException {
1807: IJasperDefinition design = null;
1808: if ((reportResult.getReportSpec().getLayoutDesign()==null) || reportResult.getReportSpec().getLayoutDesign().equals("")) {
1809: if (reportResult.getReportSpec().getReportType().getType() == ReportDefinitionReportTypeType.CUBE_TYPE) {
1810: design = new CubeJasperReportDefinition(reportResult, reportTableModel.getModel(), reportTableModel.getGroupingDimCount(), reportTableModel.getCommonMetricsCount(),
1811: reportTableModel.getNonGroupingDimCount(), reportTableModel.getAccMetricsCount(), tittle);
1812: } else {
1813: design = new StaticJasperReportDefinition(reportResult, reportTableModel.getModel(), reportTableModel.getGroupingDimCount(), reportTableModel.getCommonMetricsCount(),
1814: reportTableModel.getNonGroupingDimCount(), reportTableModel.getAccMetricsCount(), tittle);
1815: }
1816: } else {
1817: String layoutName = reportResult.getReportSpec().getLayoutDesign().endsWith(".xml") ? reportResult.getReportSpec().getLayoutDesign() : reportResult.getReportSpec().getLayoutDesign() + ".xml";
1818: design = new ExternalJasperDefinition(getReportGeneratorConfiguration().getSourceReportLayoutPath() + "/" + layoutName);
1819: }
1820: return design;
1821: }
1822:
1823: private void setJasperCompiler() {
1824: if (!reportGeneratorConfiguration.getJasperCompilerClass().equals("")) {
1825: System.setProperty("jasper.reports.compiler.class", reportGeneratorConfiguration.getJasperCompilerClass());
1826: } else if (!reportGeneratorConfiguration.getJasperReportPath().equals("")) {
1827: System.setProperty("jasper.reports.compile.class.path", reportGeneratorConfiguration.getJasperReportPath());
1828: }
1829: }*/
1830:
1831: public boolean addNewUser(String rootPasswd, String userName,
1832: String password, String userRepositoryPath)
1833: throws InfoException {
1834: UsersRepository repository = new UsersRepository(
1835: userRepositoryPath);
1836: if (repository.validate("root", rootPasswd)) {
1837: repository.addNewUser(userName, password);
1838: return true;
1839: }
1840: return false;
1841: }
1842:
1843: public void addUserData(String userName, String name,
1844: String company, String userDataRepositoryPath)
1845: throws InfoException {
1846: UserDataRepository repository = new UserDataRepository(
1847: userDataRepositoryPath);
1848: repository.addNewUser(userName, name, company);
1849: }
1850:
1851: public MicroReport getMicroReport(String fileName)
1852: throws InfoException {
1853: return new MicroReport(fileName,
1854: getReportGeneratorConfiguration());
1855: }
1856:
1857: public MicroReport getMicroReport(String reportDefinitionId,
1858: Map param) throws InfoException {
1859: MicroReportRepository microReportRepository = new MicroReportRepository(
1860: reportGeneratorConfiguration
1861: .getMicroReportRepositoryPath(),
1862: reportGeneratorConfiguration);
1863: return microReportRepository.findMicroReport(
1864: reportDefinitionId, param);
1865: }
1866:
1867: public Collection getUserData(String userId,
1868: String userDataRepositoryPath) throws InfoException {
1869: UserDataRepository repository = new UserDataRepository(
1870: userDataRepositoryPath);
1871: return repository.getUserData(userId);
1872: }
1873:
1874: public void logClientData(String clientData) throws InfoException {
1875: clientData = "Time: " + new Date() + " - " + clientData;
1876: try {
1877: OutputStream stream = getClientLogger();
1878: stream.write((clientData + "\n").getBytes());
1879: } catch (IOException e) {
1880: throw new InfoException(LanguageTraslator.traslate("465"),
1881: e);
1882: }
1883: System.out.println(clientData);
1884: }
1885:
1886: private OutputStream getClientLogger() throws FileNotFoundException {
1887: String fileName = getReportGeneratorConfiguration()
1888: .getClientLogFile();
1889: FileOutputStream stream = new FileOutputStream(fileName, true);
1890: return stream;
1891: }
1892:
1893: public boolean changePasswd(String userName, String oldPasswd,
1894: String newPasswd, String userRepositoryPath)
1895: throws InfoException {
1896: UsersRepository repository = new UsersRepository(
1897: userRepositoryPath);
1898: if (repository.validate(userName, oldPasswd)) {
1899: repository.changePasswd(userName, newPasswd);
1900: return true;
1901: }
1902: return false;
1903: }
1904:
1905: public boolean deleteUser(String userName, String password,
1906: String userRepositoryPath) throws InfoException {
1907: UsersRepository repository = new UsersRepository(
1908: userRepositoryPath);
1909: if (repository.validate(userName, password)) {
1910: repository.deleteUser(userName);
1911: return true;
1912: }
1913: return false;
1914: }
1915:
1916: public void addUserRol(String userName, String rol,
1917: String rolsRepositoryPath) throws InfoException {
1918: RolsRepository repository = new RolsRepository(
1919: rolsRepositoryPath);
1920: repository.addUserRol(userName, rol);
1921: }
1922:
1923: private TempRepository getTempRepository() throws InfoException {
1924: if (tempRepository == null) {
1925: tempRepository = new TempRepository(
1926: getReportGeneratorConfiguration().getTempPath());
1927: }
1928: return tempRepository;
1929: }
1930:
1931: public boolean isAcceptedLicence() throws InfoException {
1932: return getTempRepository().isAcceptedLicence();
1933: }
1934:
1935: public void acceptedLicence(boolean value) throws InfoException {
1936: getTempRepository().acceptedLicence(value);
1937: }
1938:
1939: }
|