ips1ap101.lib.core.db.util.Reporter.java Source code

Java tutorial

Introduction

Here is the source code for ips1ap101.lib.core.db.util.Reporter.java

Source

/*
 * Este programa es software libre; usted puede redistribuirlo y/o modificarlo bajo los trminos
 * de la licencia "GNU General Public License" publicada por la Fundacin "Free Software Foundation".
 * Este programa se distribuye con la esperanza de que pueda ser til, pero SIN NINGUNA GARANTIA;
 * vea la licencia "GNU General Public License" para obtener mas informacin.
 */
package ips1ap101.lib.core.db.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import ips1ap101.lib.base.BaseBundle;
import ips1ap101.lib.base.app.constant.EAB;
import ips1ap101.lib.base.bundle.BundleWebui;
import ips1ap101.lib.base.constant.CBM;
import ips1ap101.lib.base.entity.enumeration.CondicionEjeFunEnumeration;
import ips1ap101.lib.base.enumeration.EnumFormatoGuardar;
import ips1ap101.lib.base.enumeration.EnumFormatoInforme;
import ips1ap101.lib.base.util.ThrowableUtils;
import ips1ap101.lib.core.app.Bitacora;
import ips1ap101.lib.core.app.ExcepcionAplicacion;
import ips1ap101.lib.core.app.TLC;
import ips1ap101.lib.core.constant.EAC;
import ips1ap101.lib.core.constant.Global;
import ips1ap101.lib.core.control.Auditor;
import ips1ap101.lib.core.control.UsuarioActual;
import ips1ap101.lib.core.jms.message.ReporterMessage;
import ips1ap101.lib.core.util.EA;
import ips1ap101.lib.core.util.STP;
import ips1ap101.lib.core.util.Utils;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JRParameter;
import net.sf.jasperreports.engine.JRResultSetDataSource;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.export.JRXlsExporter;
import net.sf.jasperreports.engine.export.JRXlsExporterParameter;
import net.sf.jasperreports.engine.fill.JRFillParameter;
import org.apache.commons.lang.StringUtils;

/**
 * @author Jorge Campins
 */
public class Reporter {

    private static final String DEFAULT_NUMBER_KW = "DEFAULT";

    private static final String DEFAULT_TARGET_KW = "DEFAULT";

    private static final String DEFAULT_SELECT_KW = "DEFAULT";

    private static final int LIMITE_FILAS_FUNCION_SELECT = 10000;

    private static final EnumFormatoGuardar FORMATO_GUARDAR = EnumFormatoGuardar.INFORME;

    public static int getLimiteFilasFuncionSelect(String informe) {
        UsuarioActual usuario = TLC.getUsuarioActual();
        return getLimiteFilasFuncionSelect(informe, usuario);
    }

    private static int getLimiteFilasFuncionSelect(String informe, UsuarioActual usuario) {
        Integer limiteFilas = Utils.getReportRowsLimit(informe, FORMATO_GUARDAR, usuario);
        if (limiteFilas != null) {
            return limiteFilas;
        }
        String string = BaseBundle.getLimiteFilasFuncionReport(informe);
        int limite = StringUtils.isNotBlank(string) && StringUtils.isNumeric(string) ? Integer.valueOf(string) : -1;
        return limite < 0 ? LIMITE_FILAS_FUNCION_SELECT : limite;
    }

    public static EnumFormatoInforme getReportType(String formato) {
        String str = StringUtils.trimToEmpty(formato);
        EnumFormatoInforme tipo = EnumFormatoInforme.PDF;
        if (EnumFormatoInforme.XLS.getExtension().equalsIgnoreCase(str)) {
            tipo = EnumFormatoInforme.XLS;
        }
        return tipo;
    }

    public static String getReportFormat(EnumFormatoInforme tipo) {
        String formato;
        switch (tipo) {
        case XLS:
            formato = EnumFormatoInforme.XLS.getExtension();
            break;
        //          case CSV:
        //              formato = EnumFormatoInforme.CSV.getExtension();
        //              break;
        default:
            formato = EnumFormatoInforme.PDF.getExtension();
            break;
        }
        return formato;
    }
    //
    //  public static JasperReport getJasperReport(String informe) {
    //      try {
    //          // OJO: hay que copiar jdt-compiler.jar a jre\ext o incluirlo en el CLASSPATH para compilar el archivo jrxml
    //          // OJO: compilar el archivo jrxml de origen evita problemas al cambiar la version de jasper
    //          return JasperCompileManager.compileReport(getReportSourceFileName(informe, usuario));
    //      } catch (Exception ex) {
    //          Bitacora.trace(ThrowableUtils.getString(ex));
    //          return null;
    //      }
    //  }

    public static String getReportSourceFileName(String informe) {
        Long usuario = TLC.getUsuarioActual().getIdUsuario();
        return getReportSourceFileName(informe, usuario);
    }

    private static String getReportSourceFileName(String informe, Long usuario) {
        String report = BaseBundle.getName(informe);
        File file = getReportSourceFile(report, usuario);
        return file == null ? report : file.getPath();
    }

    public static File getUserDefinedReportsDir() {
        String sep = System.getProperties().getProperty("file.separator");
        String dir = Utils.sep(EA.getString(EAC.REPORT_SOURCE_DIR));
        Long usuario = TLC.getUsuarioActual().getIdUsuario();
        String foo = "user-defined" + sep + Utils.getUserDir(usuario);
        File file = new File(dir + foo);
        if (file.isDirectory() || file.mkdirs()) {
            return file;
        }
        return null;
    }
    //
    //  public static File getUserDefinedReportSourceFile(String informe) {
    //      String sep = System.getProperties().getProperty("file.separator");
    //      String dir = Utils.sep(EA.getString(EAC.REPORT_SOURCE_DIR));
    //      Long usuario = TLC.getUsuarioActual().getIdUsuario();
    //      String foo = "user-defined" + sep + Utils.userdir(usuario);
    //      String jrx = informe + "." + "jrxml";
    //      File file = new File(dir + foo + sep + jrx);
    //      if (file.exists()) {
    //          return file;
    //      }
    //      return null;
    //  }

    private static File getReportSourceFile(String informe, Long usuario) {
        String sep = System.getProperties().getProperty("file.separator");
        String dir = Utils.sep(EA.getString(EAC.REPORT_SOURCE_DIR));
        String fee = "custom-made";
        String faa = "entity-list";
        String foo = "user-defined" + sep + Utils.getUserDir(usuario);
        String jrx = informe + "." + "jrxml";
        File file1 = new File(dir + fee + sep + jrx);
        if (file1.exists()) {
            return file1;
        }
        File file2 = new File(dir + faa + sep + jrx);
        if (file2.exists()) {
            return file2;
        }
        File file3 = new File(dir + foo + sep + jrx);
        if (file3.exists()) {
            return file3;
        }
        return null;
    }

    public static Process executeReport(String informe, long funcion) {
        return executeReport(informe, funcion, null, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW, null);
    }

    public static Process executeReport(String informe, long funcion, EnumFormatoInforme tipo) {
        return executeReport(informe, funcion, null, tipo, DEFAULT_SELECT_KW, null);
    }

    public static Process executeReport(String informe, long funcion, String select) {
        return executeReport(informe, funcion, null, EnumFormatoInforme.PDF, select, null);
    }

    public static Process executeReport(String informe, long funcion, Map parametros) {
        return executeReport(informe, funcion, null, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW,
                getReportParametersArray(parametros));
    }

    public static Process executeReport(String informe, long funcion, EnumFormatoInforme tipo, String select) {
        return executeReport(informe, funcion, null, tipo, select, null);
    }

    public static Process executeReport(String informe, long funcion, EnumFormatoInforme tipo, Map parametros) {
        return executeReport(informe, funcion, null, tipo, DEFAULT_SELECT_KW, getReportParametersArray(parametros));
    }

    public static Process executeReport(String informe, long funcion, String select, Object[] args) {
        return executeReport(informe, funcion, null, EnumFormatoInforme.PDF, select, args);
    }

    public static Process executeReport(String informe, long funcion, String destino, EnumFormatoInforme tipo) {
        return executeReport(informe, funcion, destino, tipo, DEFAULT_SELECT_KW, null);
    }

    public static Process executeReport(String informe, long funcion, String destino, String select) {
        return executeReport(informe, funcion, destino, EnumFormatoInforme.PDF, select, null);
    }

    public static Process executeReport(String informe, long funcion, String destino, Map parametros) {
        return executeReport(informe, funcion, destino, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW,
                getReportParametersArray(parametros));
    }

    public static Process executeReport(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            String select) {
        return executeReport(informe, funcion, destino, tipo, select, null);
    }

    public static Process executeReport(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            Map parametros) {
        return executeReport(informe, funcion, destino, tipo, DEFAULT_SELECT_KW,
                getReportParametersArray(parametros));
    }

    public static Process executeReport(String informe, long funcion, String destino, String select,
            Object[] args) {
        return executeReport(informe, funcion, destino, EnumFormatoInforme.PDF, select, args);
    }

    public static Process executeReport(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            String select, Object[] args) {
        Bitacora.trace(Reporter.class, "executeReport", informe, String.valueOf(funcion), destino,
                String.valueOf(tipo));
        Bitacora.trace(select);
        Utils.traceObjectArray(args);
        Long rastro = null;
        Process subprocess = null;
        try {
            String report = BaseBundle.getName(informe);
            if (STP.esIdentificadorArchivoValido(report)) {
                if (TLC.getControlador().esFuncionAutorizada(funcion)) {
                    String formato = tipo == null ? "?" : tipo.name();
                    int limite = getLimiteFilasFuncionSelect(informe);
                    rastro = TLC.getControlador().ponerInformePendiente(funcion, informe, formato, limite);
                    String path = Utils.sep(EA.getString(EAC.REPORT_RUNNER_DIR));
                    String command = path + EA.getString(EAC.REPORT_RUNNER_CMD);
                    command += " " + commandParameters(informe, rastro, destino, tipo, select, args);
                    String[] envp = null;
                    File dir = new File(path);
                    Bitacora.trace(command);
                    Bitacora.trace(dir.getPath());
                    subprocess = Runtime.getRuntime().exec(command, envp, dir);
                    TLC.getBitacora().info(CBM.REPORT_EXECUTION_REQUEST, informe);
                } else {
                    throw new ExcepcionAplicacion(Bitacora.getTextoMensaje(CBM.FUNCION_NO_AUTORIZADA, informe));
                }
            } else {
                throw new ExcepcionAplicacion(
                        Bitacora.getTextoMensaje(CBM.IDENTIFICADOR_ARCHIVO_INVALIDO, informe));
            }
        } catch (Exception ex) {
            CondicionEjeFunEnumeration condicion = CondicionEjeFunEnumeration.EJECUCION_CANCELADA;
            String mensaje = ThrowableUtils.getString(ex);
            Auditor.grabarRastroInforme(rastro, condicion, null, mensaje);
            TLC.getBitacora().error(mensaje);
        }
        return subprocess;
    }

    private static String commandParameters(String informe, Long rastro, String destino, EnumFormatoInforme tipo,
            String select, Object[] args) {
        String str = informe + " " + rastro;
        str += " " + trimToDefaultTarget(destino);
        str += " " + getReportFormat(tipo);
        str += " " + Utils.getQuotedParameterString(Utils.encodeSelect(trimToDefaultSelect(select)));
        str += " " + Utils.getQuotedParameterString(args);
        return str;
    }

    public static ReporterMessage report(String informe, long funcion) {
        return report(informe, funcion, null, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW, null);
    }

    public static ReporterMessage report(String informe, long funcion, EnumFormatoInforme tipo) {
        return report(informe, funcion, null, tipo, DEFAULT_SELECT_KW, null);
    }

    public static ReporterMessage report(String informe, long funcion, String select) {
        return report(informe, funcion, null, EnumFormatoInforme.PDF, select, null);
    }

    public static ReporterMessage report(String informe, long funcion, Map parametros) {
        return report(informe, funcion, null, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW,
                getReportParametersArray(parametros), parametros);
    }

    public static ReporterMessage report(String informe, long funcion, EnumFormatoInforme tipo, String select) {
        return report(informe, funcion, null, tipo, select, null);
    }

    public static ReporterMessage report(String informe, long funcion, EnumFormatoInforme tipo, Map parametros) {
        return report(informe, funcion, null, tipo, DEFAULT_SELECT_KW, getReportParametersArray(parametros),
                parametros);
    }

    public static ReporterMessage report(String informe, long funcion, String select, Object[] args) {
        return report(informe, funcion, null, EnumFormatoInforme.PDF, select, args, null);
    }

    public static ReporterMessage report(String informe, long funcion, String select, Object[] args,
            Map parametros) {
        return report(informe, funcion, null, EnumFormatoInforme.PDF, select, args, parametros);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, EnumFormatoInforme tipo) {
        return report(informe, funcion, destino, tipo, DEFAULT_SELECT_KW, null);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, String select) {
        return report(informe, funcion, destino, EnumFormatoInforme.PDF, select, null);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, Map parametros) {
        return report(informe, funcion, destino, EnumFormatoInforme.PDF, DEFAULT_SELECT_KW,
                getReportParametersArray(parametros), parametros);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            String select) {
        return report(informe, funcion, destino, tipo, select, null);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            Map parametros) {
        return report(informe, funcion, destino, tipo, DEFAULT_SELECT_KW, getReportParametersArray(parametros),
                parametros);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, String select,
            Object[] args) {
        return report(informe, funcion, destino, EnumFormatoInforme.PDF, select, args, null);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, String select, Object[] args,
            Map parametros) {
        return report(informe, funcion, destino, EnumFormatoInforme.PDF, select, args, parametros);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            String select, Object[] args) {
        return report(informe, funcion, destino, EnumFormatoInforme.PDF, select, args, null);
    }

    public static ReporterMessage report(String informe, long funcion, String destino, EnumFormatoInforme tipo,
            String select, Object[] args, Map parametros) {
        Bitacora.trace(Reporter.class, "report", informe, String.valueOf(funcion), destino, String.valueOf(tipo));
        Long rastro = null;
        try {
            String report = BaseBundle.getName(informe);
            if (STP.esIdentificadorArchivoValido(report)) {
                if (TLC.getControlador().esFuncionAutorizada(funcion)) {
                    String formato = tipo == null ? "?" : tipo.name();
                    int limite = getLimiteFilasFuncionSelect(informe);
                    rastro = TLC.getControlador().ponerInformePendiente(funcion, informe, formato, limite);
                    return report(informe, rastro, TLC.getUsuarioActual(), destino, tipo, select, false, args,
                            parametros, TLC.getLocale(), false);
                } else {
                    throw new ExcepcionAplicacion(Bitacora.getTextoMensaje(CBM.FUNCION_NO_AUTORIZADA, informe));
                }
            } else {
                throw new ExcepcionAplicacion(
                        Bitacora.getTextoMensaje(CBM.IDENTIFICADOR_ARCHIVO_INVALIDO, informe));
            }
        } catch (Exception ex) {
            CondicionEjeFunEnumeration condicion = CondicionEjeFunEnumeration.EJECUCION_CANCELADA;
            String mensaje = ThrowableUtils.getString(ex);
            Auditor.grabarRastroInforme(rastro, condicion, null, mensaje);
            TLC.getBitacora().error(mensaje);
        }
        return null;
    }

    public static ReporterMessage report(ReporterMessage message) {
        return report(message.getInforme(), message.getRastro(), message.getUsuarioActual(), message.getDestino(),
                message.getTipo(), message.getSelect(), message.isSelectRestringido(), message.getArgs(),
                message.getParameters(), message.getLocale(), false);
    }

    static ReporterMessage report(String report, String number, String userid, String target, String format,
            String select, Object[] args, boolean logging) {
        Bitacora.trace(Reporter.class, "report", report, number, target, format);
        String informe = StringUtils.trimToEmpty(report);
        Long rastro = trimToNullNumber(number);
        Long usuario = StringUtils.isNotBlank(userid) && StringUtils.isNumeric(userid) ? Long.valueOf(userid)
                : null;
        String destino = trimToNullTarget(target);
        EnumFormatoInforme tipo = getReportType(format);
        String decode = Utils.decodeSelect(trimToNullSelect(select));
        return report(informe, rastro, usuario, destino, tipo, decode, false, args, null, null, logging);
    }

    private static ReporterMessage report(String informe, Long rastro, Object usuario, String destino,
            EnumFormatoInforme tipo, String select, boolean restringido, Object[] args, Map parametros,
            Locale locale, boolean logging) {
        Bitacora.trace(Reporter.class, "report", informe, rastro, destino, tipo);
        Bitacora.trace(trimToDefaultSelect(select));
        Utils.traceObjectArray(args);
        UsuarioActual usuarioActual = usuario instanceof UsuarioActual ? (UsuarioActual) usuario : null;
        Long userid = usuarioActual == null ? usuario instanceof Long ? (Long) usuario : null
                : usuarioActual.getIdUsuario();
        String usercode = usuarioActual == null ? null : usuarioActual.getCodigoUsuario();
        String username = usuarioActual == null ? null : usuarioActual.getCodigoUsuario();
        String report = BaseBundle.getName(informe);
        String target = trimToNullTarget(destino);
        String format = getReportFormat(tipo);
        ResultSet resultSet = null;
        //      String archivo = logging ? getLogFileName(rastro) : null;
        String archivo = null;
        CondicionEjeFunEnumeration condicion = CondicionEjeFunEnumeration.EJECUCION_EN_PROGRESO;
        String mensaje = TLC.getBitacora().info(CBM.REPORT_EXECUTION_BEGIN, report);
        boolean ok = Auditor.grabarRastroInforme(rastro, condicion, archivo, mensaje);
        if (ok) {
            try {
                // OJO: hay que copiar jdt-compiler.jar a jre\ext o incluirlo en el CLASSPATH para compilar el archivo jrxml
                // OJO: compilar el archivo jrxml de origen evita problemas al cambiar la version de jasper
                JasperPrint jasperPrint = null;
                File sourceFile = getReportSourceFile(report, userid);
                if (sourceFile == null) {
                    throw new FileNotFoundException(Bitacora.getTextoMensaje(CBM.INFORME_NO_EXISTE, report));
                }
                String sourceFileName = sourceFile.getPath();
                JasperReport jasperReport = JasperCompileManager.compileReport(sourceFileName);
                Map parameters = getReportParametersMap(sourceFile, format, userid, usercode, username, locale,
                        parametros);
                if (StringUtils.isBlank(select)) {
                    jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, TLC.getConnection());
                    if (jasperPrint == null) {
                        condicion = CondicionEjeFunEnumeration.EJECUCION_CANCELADA;
                        mensaje = TLC.getBitacora().error(CBM.REPORT_EXECUTION_ABEND, report);
                    }
                } else {
                    if (!restringido) {
                        select = Utils.replaceWhereClause(jasperReport.getQuery().getText(), select);
                    }
                    if (StringUtils.isBlank(select)) {
                        condicion = CondicionEjeFunEnumeration.EJECUTADO_CON_ERRORES;
                        mensaje = TLC.getBitacora().error(CBM.ERROR_COMANDO_SELECT);
                    } else {
                        int limite = getLimiteFilasFuncionSelect(informe, usuarioActual);
                        resultSet = TLC.getAgenteSql().executeQuery(select, limite, args);
                        if (resultSet.isBeforeFirst()) {
                            parameters.put("SQL_SELECT_STATEMENT", select);
                            JRResultSetDataSource dataSource = new JRResultSetDataSource(resultSet);
                            jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, dataSource);
                            if (jasperPrint == null) {
                                condicion = CondicionEjeFunEnumeration.EJECUCION_CANCELADA;
                                mensaje = TLC.getBitacora().error(CBM.REPORT_EXECUTION_ABEND, report);
                            }
                        } else {
                            condicion = CondicionEjeFunEnumeration.EJECUTADO_SIN_ERRORES;
                            mensaje = TLC.getBitacora().error(CBM.SELECT_ROW_EMPTY_SET, report);
                        }
                    }
                }
                if (jasperPrint != null) {
                    archivo = report(jasperPrint, target, format, userid);
                    condicion = CondicionEjeFunEnumeration.EJECUTADO_SIN_ERRORES;
                    mensaje = TLC.getBitacora().warn(CBM.REPORT_EXECUTION_END, report);
                }
            } catch (Exception ex) {
                condicion = CondicionEjeFunEnumeration.EJECUTADO_CON_ERRORES;
                mensaje = ThrowableUtils.getString(ex);
                TLC.getBitacora().fatal(ex);
                TLC.getBitacora().fatal(CBM.REPORT_EXECUTION_ABEND, report);
            } finally {
                Auditor.grabarRastroInforme(rastro, condicion, archivo, mensaje);
                DB.close(resultSet);
            }
        } else {
            condicion = CondicionEjeFunEnumeration.EJECUCION_CANCELADA;
            mensaje = TLC.getBitacora().error(CBM.PROCESS_EXECUTION_ABEND, report);
        }
        ReporterMessage message = new ReporterMessage(report);
        message.setDestino(target);
        message.setTipo(tipo);
        message.setSelect(select);
        message.setArgs(args);
        message.setRastro(rastro);
        message.setCondicion(condicion);
        message.setArchivo(archivo);
        message.setMensaje(mensaje);
        return message;
    }

    private static String report(JasperPrint jasperPrint, String target, String format, Long usuario)
            throws Exception {
        Bitacora.trace(Reporter.class, "report", jasperPrint.getName(), target, format);
        String targetFileName;
        if (target == null) {
            targetFileName = jasperPrint.getName() + "_" + System.currentTimeMillis() + "_"
                    + jasperPrint.hashCode();
        } else {
            targetFileName = target;
        }
        targetFileName += "." + format;
        targetFileName = targetFileName.toLowerCase();
        String outputFileName = Utils.getSpooledFilesDir(usuario) + targetFileName;
        EnumFormatoInforme type = getReportType(format);
        switch (type) {
        case XLS:
            JRXlsExporter xlsExporter = new JRXlsExporter();
            xlsExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
            xlsExporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, outputFileName);
            xlsExporter.setParameter(JRXlsExporterParameter.IS_DETECT_CELL_TYPE, Boolean.TRUE);
            xlsExporter.setParameter(JRXlsExporterParameter.IS_FONT_SIZE_FIX_ENABLED, Boolean.TRUE);
            xlsExporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);
            xlsExporter.setParameter(JRXlsExporterParameter.IS_REMOVE_EMPTY_SPACE_BETWEEN_ROWS, Boolean.TRUE);
            xlsExporter.setParameter(JRXlsExporterParameter.IS_WHITE_PAGE_BACKGROUND, Boolean.FALSE);
            //              xlsExporter.setParameter(JRXlsExporterParameter.MAXIMUM_ROWS_PER_SHEET, Integer.valueOf(0));
            xlsExporter.exportReport();
            break;
        //          case CSV:
        //              JRCsvExporter csvExporter = new JRCsvExporter();
        //              csvExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
        //              csvExporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, outputFileName);
        //              csvExporter.setParameter(JRCsvExporterParameter.FIELD_DELIMITER, ";");
        //              csvExporter.exportReport();
        //              break;
        default:
            JasperExportManager.exportReportToPdfFile(jasperPrint, outputFileName);
            break;
        }
        return Utils.getWebServerRelativePath(outputFileName);
    }

    //  private static String getLogFileName(Long rastro) {
    //      if (rastro == null || rastro == 0) {
    //          return null;
    //      }
    //      return System.getenv(SEV.REPORT_RUNNER_LOG);
    //  }
    //
    //  private static String trimToDefaultNumber(String number) {
    //      String str = StringUtils.trimToEmpty(number);
    //      return StringUtils.isEmpty(str) || !StringUtils.isNumeric(str) ? DEFAULT_NUMBER_KW : str;
    //  }
    //
    private static String trimToDefaultTarget(String target) {
        String str = StringUtils.trimToEmpty(target);
        return StringUtils.isEmpty(str) || !STP.esIdentificadorArchivoValido(str) ? DEFAULT_TARGET_KW : str;
    }

    private static String trimToDefaultSelect(String select) {
        String str = StringUtils.trimToEmpty(select);
        return StringUtils.isEmpty(str) ? DEFAULT_SELECT_KW : str;
    }

    private static Long trimToNullNumber(String number) {
        String str = StringUtils.trimToEmpty(number);
        return StringUtils.isEmpty(str) || str.equalsIgnoreCase(DEFAULT_NUMBER_KW) || !StringUtils.isNumeric(str)
                ? null
                : Long.valueOf(str);
    }

    private static String trimToNullTarget(String target) {
        String str = StringUtils.trimToEmpty(target);
        return StringUtils.isEmpty(str) || str.equalsIgnoreCase(DEFAULT_TARGET_KW)
                || !STP.esIdentificadorArchivoValido(str) ? null : str;
    }

    private static String trimToNullSelect(String select) {
        String str = StringUtils.trimToEmpty(select);
        return StringUtils.isEmpty(str) || str.equalsIgnoreCase(DEFAULT_SELECT_KW) ? null : str;
    }

    private static Object[] getReportParametersArray(Map parameters) {
        if (parameters == null || parameters.isEmpty()) {
            return null;
        }
        int n = parameters.size();
        Object[] args = new Object[n];
        Set set = parameters.keySet();
        Iterator iterator = set.iterator();
        Object key;
        Object val;
        String psi;
        String str;
        for (int i = 0; i < n && iterator.hasNext(); i++) {
            key = iterator.next();
            val = parameters.get(key);
            if (val != null) {
                psi = val instanceof Long ? Global.PREFIJO_STRING_ID_RECURSO : "";
                str = StringUtils.trimToEmpty(STP.getString(val));
                args[i] = key + "=" + psi + str;
                Bitacora.trace("args [" + i + "] = " + key + "=(" + val.getClass().getSimpleName() + ")" + str);
            }
        }
        return args;
    }

    private static Map getReportParametersMap(File file, String format, Long userid, String usercode,
            String username, Locale locale, Map parametros) {
        Map parameters = getReportParametersMap(file, format, userid, usercode, username, locale);
        if (parametros != null && !parametros.isEmpty()) {
            parameters.putAll(parametros);
        }
        return parameters;
    }

    private static Map getReportParametersMap(File file, String format, Long userid, String usercode,
            String username, Locale locale) {
        Bitacora.trace(Reporter.class, "getReportParametersMap", file.getName(), file.getParent(), file.getPath());
        Map parameters = new HashMap();
        EnumFormatoInforme type = getReportType(format);
        String sep = System.getProperties().getProperty("file.separator");
        String parent = getParent(file, userid);
        parameters.put(JRParameter.REPORT_LOCALE, locale == null ? Locale.getDefault() : locale);
        parameters.put(JRFillParameter.REPORT_CONNECTION, TLC.getConnection());
        parameters.put("ENTERPRISE_APPLICATION_CODE", EAB.ENTERPRISE_APPLICATION_CODE);
        parameters.put("ENTERPRISE_APPLICATION_NAME", BundleWebui.getString(EAB.ENTERPRISE_APPLICATION_CODE));
        parameters.put("RESOURCES_DIR", parent + sep + "resources" + sep);
        parameters.put("SUBREPORTS_DIR", parent + sep + "subreports" + sep);
        parameters.put("END_USER_ID", userid);
        parameters.put("END_USER_CODE", usercode);
        parameters.put("END_USER_NAME", username);
        parameters.put("SQL_SELECT_STATEMENT", "");
        parameters.put("SQL_WHERE_CLAUSE", "");
        parameters.put("SQL_LIMIT_CLAUSE", "");
        switch (type) {
        case XLS:
            parameters.put(JRFillParameter.IS_IGNORE_PAGINATION, Boolean.TRUE);
            parameters.put(JRFillParameter.REPORT_MAX_COUNT, Integer.valueOf(60000));
            break;
        //          case CSV:
        //              parameters.put(JRFillParameter.IS_IGNORE_PAGINATION, Boolean.TRUE);
        //              parameters.put(JRFillParameter.REPORT_MAX_COUNT, null);
        //              break;
        default:
            parameters.put(JRFillParameter.IS_IGNORE_PAGINATION, Boolean.FALSE);
            parameters.put(JRFillParameter.REPORT_MAX_COUNT, null);
            break;
        }
        return parameters;
    }

    private static String getParent(File file, Long usuario) {
        String sep = System.getProperties().getProperty("file.separator");
        String path = file.getPath();
        String substring = sep + "user-defined" + sep + Utils.getUserDir(usuario) + sep;
        return StringUtils.contains(path, substring) ? file.getParentFile().getParent() : file.getParent();
    }

}