Java tutorial
/* * 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.app; import java.util.Collection; import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; import ips1ap101.lib.base.bundle.BundleParametros; import ips1ap101.lib.base.constant.CBM; import ips1ap101.lib.base.entity.enumeration.OperadorComEnumeration; import ips1ap101.lib.base.entity.enumeration.TipoDatoParEnumeration; import ips1ap101.lib.base.entity.enumeration.TipoValorEnumeration; import ips1ap101.lib.base.persistence.entity.FiltroFuncionBase; import ips1ap101.lib.base.persistence.entity.FiltroFuncionParBase; import ips1ap101.lib.base.util.TemporalAddend; import ips1ap101.lib.core.db.util.DB; import ips1ap101.lib.core.enumeration.EnumConjuncion; import ips1ap101.lib.core.util.STP; import ips1ap101.lib.core.web.app.EJBL; import org.apache.commons.lang.StringUtils; /** * @author Jorge Campins */ public class FiltroBusqueda { /** * Creates a new instance of FiltroBusqueda */ public FiltroBusqueda() { this.init(); } /** * Creates a new instance of FiltroBusqueda from the criteria stored in the database */ public FiltroBusqueda(long filtro) { this.init(); this.populate(filtro); } private void init() { criterios = new LinkedHashSet<>(); filtros = new LinkedHashSet<>(); conjuncion = EnumConjuncion.Y; } private Set<CriterioBusqueda> criterios; private Set<CriterioBusqueda> getCriterios() { return criterios; } private Set<FiltroBusqueda> filtros; private Set<FiltroBusqueda> getFiltros() { return filtros; } private EnumConjuncion conjuncion; public EnumConjuncion getConjuncion() { return conjuncion; } public void setConjuncion(EnumConjuncion conjuncion) { this.conjuncion = conjuncion; } private void populate(long filtro) { FiltroFuncionBase ff = EJBL.getFiltroFuncionFacade().find(filtro, true); if (ff != null) { long funcion = ff.getIdFuncion().getIdFuncion(); boolean filtrarConRestricciones = TLC.getControlador().esFuncionConParametrosRestringidos(funcion); Collection<? extends FiltroFuncionParBase> parametros = ff .getFiltroFuncionParByIdFiltroFuncionCollection(); if (parametros != null && !parametros.isEmpty()) { String dominio = ff.getIdFuncion().getIdDominio().getCodigoDominio(); String codigo1; String codigo2; String columna; Integer i; OperadorComEnumeration operadorCom; TipoValorEnumeration tipoValor; TipoDatoParEnumeration tipoDatoPar; String string; Object objeto; // String prefijo1 = dominio + "."; String prefijo2 = dominio + "." + DB.SELECT + "."; for (FiltroFuncionParBase ffp : parametros) { Boolean criterioBusqueda = ffp.getIdFuncionParametro().getCriterioBusqueda(); if (criterioBusqueda == null || !criterioBusqueda) { continue; } codigo1 = ffp.getIdFuncionParametro().getIdParametro().getCodigoParametro(); codigo2 = ffp.getIdFuncionParametro().getCodigoFuncionParametro(); // columna = StringUtils.removeStartIgnoreCase(codigo1, prefijo1); columna = StringUtils.removeStartIgnoreCase(codigo2, prefijo2); if (filtrarConRestricciones && !TLC.getControlador().esParametroAutorizado(columna, funcion)) { TLC.getBitacora().warn(CBM.SELECT_FILTER_EXCEPTION_1, BundleParametros.getLabel(codigo1)); continue; } i = ffp.getNumeroOperadorCom().getNumeroOperadorCom(); operadorCom = OperadorComEnumeration.valueOf(i); i = ffp.getIdFuncionParametro().getNumeroTipoValor().getNumeroTipoValor(); tipoValor = TipoValorEnumeration.valueOf(i); i = ffp.getIdFuncionParametro().getNumeroTipoDatoPar().getNumeroTipoDatoPar(); tipoDatoPar = TipoDatoParEnumeration.valueOf(i); if (tipoValor == null) { objeto = null; } else { switch (tipoValor) { case CONTINUO: if (TipoDatoParEnumeration.FECHA_HORA.equals(tipoDatoPar)) { string = ffp.getValor(); objeto = ffp.getValorFechaHora(); if (string != null && objeto == null) { TemporalAddend addend = new TemporalAddend(string); if (addend.isValid()) { objeto = addend; } } } else { string = ffp.getValor(); objeto = STP.getObjeto(string, tipoDatoPar); } break; case RECURSO: objeto = ffp.getIdRecursoValor(); break; default: objeto = null; break; } } if (this.isCriterioValido(operadorCom, tipoValor, tipoDatoPar)) { this.addCriterio(columna, operadorCom, objeto); } } } } } private boolean isCriterioValido(OperadorComEnumeration operadorCom, TipoValorEnumeration tipoValor, TipoDatoParEnumeration tipoDatoPar) { switch (operadorCom) { case ES_NULO: case NO_ES_NULO: return true; case ESTA_ENTRE: case NO_ESTA_ENTRE: case ES_NULO_O_ESTA_ENTRE: case ES_NULO_O_NO_ESTA_ENTRE: case EXISTE: case NO_EXISTE: return false; default: switch (tipoValor) { case CONTINUO: switch (tipoDatoPar) { case LOGICO: switch (operadorCom) { case ES_VERDADERO: case NO_ES_VERDADERO: case ES_FALSO: case NO_ES_FALSO: return true; default: return false; } case ALFANUMERICO: switch (operadorCom) { case ES_VERDADERO: case NO_ES_VERDADERO: case ES_FALSO: case NO_ES_FALSO: return false; default: return true; } default: switch (operadorCom) { case ES_IGUAL: case NO_ES_IGUAL: case ES_MAYOR: case ES_MENOR_O_IGUAL: case ES_MAYOR_O_IGUAL: case ES_MENOR: case ES_NULO_O_ES_IGUAL: case ES_NULO_O_NO_ES_IGUAL: case ES_NULO_O_ES_MAYOR: case ES_NULO_O_ES_MENOR_O_IGUAL: case ES_NULO_O_ES_MAYOR_O_IGUAL: case ES_NULO_O_ES_MENOR: return true; default: return false; } } default: switch (operadorCom) { case ES_IGUAL: case NO_ES_IGUAL: case ES_NULO_O_ES_IGUAL: case ES_NULO_O_NO_ES_IGUAL: return true; default: return false; } } } } public boolean addCriterio(CriterioBusqueda criterio) { return criterio != null && criterios.add(criterio); } public boolean addCriterio(String columna) { if (StringUtils.isBlank(columna)) { return false; } CriterioBusqueda criterio = new CriterioBusqueda(columna); return criterios.add(criterio); } public boolean addCriterio(String columna, Object valor) { if (StringUtils.isBlank(columna)) { return false; } CriterioBusqueda criterio = new CriterioBusqueda(columna, valor); return criterios.add(criterio); } public boolean addCriterio(String columna, OperadorComEnumeration comparacion, Object valor) { if (StringUtils.isBlank(columna)) { return false; } CriterioBusqueda criterio = new CriterioBusqueda(columna, comparacion, valor); return criterios.add(criterio); } public boolean addCriterio(String columna, boolean nulo) { if (StringUtils.isBlank(columna)) { return false; } CriterioBusqueda criterio = new CriterioBusqueda(columna, nulo); return criterios.add(criterio); } public boolean addCriterio(boolean existe, String expresion) { if (StringUtils.isBlank(expresion)) { return false; } CriterioBusqueda criterio = new CriterioBusqueda(existe, expresion); return criterios.add(criterio); } public boolean addFiltro(FiltroBusqueda filtro) { return filtro == null ? false : filtros.add(filtro); } public void clear() { criterios.clear(); filtros.clear(); } /** * {@inheritDoc} */ @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (obj == this) { return true; } if (obj instanceof FiltroBusqueda) { FiltroBusqueda that = (FiltroBusqueda) obj; String str1 = this.toString(); String str2 = that.toString(); if (str1 == null && str2 == null) { return true; } if (str1 == null || str2 == null) { return false; } return str1.equals(str2); } return false; } @Override public int hashCode() { int hash = 5; hash = 61 * hash + (this.criterios != null ? this.criterios.hashCode() : 0); return hash; } /** * {@inheritDoc} */ @Override public String toString() { return toString(null); } public String toString(Map<String, String> map) { String where = StringUtils.EMPTY; String token; for (CriterioBusqueda criterio : criterios) { token = criterio.toString(map); where += StringUtils.isBlank(token) ? "" : conjuncion.palabra() + token; } for (FiltroBusqueda filtro : filtros) { token = filtro.toString(map); where += StringUtils.isBlank(token) ? "" : conjuncion.palabra() + token; } where = StringUtils.removeStart(where, conjuncion.palabra()); return StringUtils.isBlank(where) ? null : "(" + where.trim() + ")"; } }