private List<String> TrocearExpresion(String expresion) { expresion = eliminarParentesisRedundantesExternos(expresion); Map<TipoOperacionCriterioEmun, List<Integer>> posicionOperacionessExternas = obtenerPosicionOperancionesExternas(expresion); Map<TipoOperacionCriterioEmun, Integer> mapaOperacion = obtenerOperacionExterna(posicionOperacionessExternas); if (mapaOperacion.isEmpty() || mapaOperacion.size() != 1) return null; List<String> result = new ArrayList<String>(); for (TipoOperacionCriterioEmun tipoOperacionEmun : mapaOperacion.keySet()) { result.add(0, tipoOperacionEmun.getRepresentacion()); if (tipoOperacionEmun.equals(TipoOperacionCriterioEmun.NOT)) { result.add( 1, expresion.substring( mapaOperacion.get(tipoOperacionEmun) + tipoOperacionEmun.getRepresentacion().length() + 1, expresion.length() - 1)); return result; } result.add(1, expresion.substring(0, mapaOperacion.get(tipoOperacionEmun))); result.add( 2, expresion.substring( mapaOperacion.get(tipoOperacionEmun) + tipoOperacionEmun.getRepresentacion().length(), expresion.length())); } return result; }
private Boolean operaTexto(TipoOperacionCriterioEmun operacion, String valorIzq, String valorDch) throws Exception { int resultado = valorIzq.toUpperCase().compareTo(valorDch.toUpperCase()); if (operacion.equals(TipoOperacionCriterioEmun.IGUAL)) return resultado == 0; if (operacion.equals(TipoOperacionCriterioEmun.DISTINTO)) return resultado != 0; throw new Exception("Fallo Operando Texto"); }
private Boolean operaLogica( TipoOperacionCriterioEmun operacion, Boolean valorIzq, Boolean valorDch) throws Exception { if (operacion.equals(TipoOperacionCriterioEmun.AND)) return valorIzq & valorDch; if (operacion.equals(TipoOperacionCriterioEmun.OR)) return valorIzq | valorDch; if (operacion.equals(TipoOperacionCriterioEmun.NOT)) return !valorIzq; throw new Exception("Fallo Operando Logica"); }
private Boolean operacionInequivoca( TipoOperacionCriterioEmun tipoOperacionEmun, String operacion) { if (tipoOperacionEmun.equals(TipoOperacionCriterioEmun.MAYOR) || tipoOperacionEmun.equals(TipoOperacionCriterioEmun.MENOR) || tipoOperacionEmun.equals(TipoOperacionCriterioEmun.IGUAL)) { if (operacion.contains(TipoOperacionCriterioEmun.MAYOR_IGUAL.getRepresentacion()) || operacion.contains(TipoOperacionCriterioEmun.MENOR_IGUAL.getRepresentacion()) || operacion.contains(TipoOperacionCriterioEmun.DISTINTO.getRepresentacion())) return false; } return true; }
private Map<TipoOperacionCriterioEmun, List<Integer>> obtenerPosicionOperancionesExternas( String expresion) { Map<TipoOperacionCriterioEmun, List<Integer>> result = new HashMap<TipoOperacionCriterioEmun, List<Integer>>(); Map<Integer, Integer> mapaParentesis = obtenerPosicionesParentesisExternos(expresion); Integer lastPosicionView = 0; for (TipoOperacionCriterioEmun tipoOperacionEmun : TipoOperacionCriterioEmun.getListaValoresEvaluacion()) { lastPosicionView = 0; List<Integer> listaPosicines = new ArrayList<Integer>(); if (tipoOperacionEmun.equals(TipoOperacionCriterioEmun.NOT)) { if ((lastPosicionView = expresion.indexOf(tipoOperacionEmun.getRepresentacion() + "(", lastPosicionView)) != -1) { if (!estaEntreParentesis(mapaParentesis, lastPosicionView) && mapaParentesis.get( lastPosicionView + TipoOperacionCriterioEmun.NOT.getRepresentacion().length()) == expresion.length() - 1) { listaPosicines.add(lastPosicionView); result.put(tipoOperacionEmun, listaPosicines); return result; } } result.put(tipoOperacionEmun, listaPosicines); continue; } while ((lastPosicionView = expresion.indexOf(tipoOperacionEmun.getRepresentacion(), lastPosicionView)) != -1) { if (!estaEntreParentesis(mapaParentesis, lastPosicionView) && operacionInequivoca( tipoOperacionEmun, expresion.substring(lastPosicionView - 1, lastPosicionView + 2))) listaPosicines.add(lastPosicionView); lastPosicionView++; } result.put(tipoOperacionEmun, listaPosicines); } return result; }
private Map<TipoOperacionCriterioEmun, Integer> obtenerOperacionExterna( Map<TipoOperacionCriterioEmun, List<Integer>> mapa) { Map<TipoOperacionCriterioEmun, Integer> result = new HashMap<TipoOperacionCriterioEmun, Integer>(); if (!mapa.get(TipoOperacionCriterioEmun.NOT).isEmpty()) { result.put(TipoOperacionCriterioEmun.NOT, mapa.get(TipoOperacionCriterioEmun.NOT).get(0)); return result; } if (!mapa.get(TipoOperacionCriterioEmun.AND).isEmpty()) { if (!mapa.get(TipoOperacionCriterioEmun.OR).isEmpty()) { if (mapa.get(TipoOperacionCriterioEmun.OR).get(0) < mapa.get(TipoOperacionCriterioEmun.AND).get(0)) result.put(TipoOperacionCriterioEmun.OR, mapa.get(TipoOperacionCriterioEmun.OR).get(0)); return result; } result.put(TipoOperacionCriterioEmun.AND, mapa.get(TipoOperacionCriterioEmun.AND).get(0)); return result; } if (!mapa.get(TipoOperacionCriterioEmun.OR).isEmpty()) { result.put(TipoOperacionCriterioEmun.OR, mapa.get(TipoOperacionCriterioEmun.OR).get(0)); return result; } // EVALUAR LA OPERACION EXTERNA MAS A LA IZQUIERDA TipoOperacionCriterioEmun operacionE = null; Integer posicionIZ = null; for (TipoOperacionCriterioEmun op : TipoOperacionCriterioEmun.getComparaciones()) { if (!(mapa.get(op).isEmpty()) && (posicionIZ == null || posicionIZ > mapa.get(op).get(0))) { posicionIZ = mapa.get(op).get(0); operacionE = op; } } result.put(operacionE, mapa.get(operacionE).get(0)); return result; }
private Boolean operaAritmetica( TipoOperacionCriterioEmun operacion, Double valorIzq, Double valorDch) throws Exception { int resultado = valorIzq.compareTo(valorDch); if (operacion.equals(TipoOperacionCriterioEmun.MAYOR)) return resultado > 0; if (operacion.equals(TipoOperacionCriterioEmun.MAYOR_IGUAL)) return resultado >= 0; if (operacion.equals(TipoOperacionCriterioEmun.MENOR)) return resultado < 0; if (operacion.equals(TipoOperacionCriterioEmun.MENOR_IGUAL)) return resultado <= 0; if (operacion.equals(TipoOperacionCriterioEmun.IGUAL)) return resultado == 0; if (operacion.equals(TipoOperacionCriterioEmun.DISTINTO)) return resultado != 0; throw new Exception("Fallo Operando Aritmetica"); }
private CriterioDto guardaCriterio( String expresion, String tipoColumna, EncapsuladorErroresSW errores) { try { List<String> trozos = TrocearExpresion(expresion); if (trozos == null) return null; CriterioDto criterioDto = new CriterioDto(); TipoOperacionCriterioEmun operacion = TipoOperacionCriterioEmun.getPorRepresentacion(trozos.get(0)); criterioDto.setTipoOperacion(operacion); // OPERANDO IZQUIERDO String operando1 = eliminarParentesisRedundantesExternos(trozos.get(1)); criterioDto.setTipoOperandoIzq(identificarTipoOperando(operando1)); if (criterioDto.getTipoOperandoIzq().equals(TipoOperandoCriterioEmun.LITERAL)) { if (esCadena(operando1)) { if (TipoAtributoFD.VALORFDNUMERICO.getDescripcion().equals(tipoColumna)) { errores.setHashErrors(true); EncapsuladorErrorSW error = new EncapsuladorErrorSW(); errores.getListaErrores().add(error); return null; } else { criterioDto.setStrLiteralIzq(operando1.substring(1, operando1.length() - 1)); criterioDto.setLiteralIzq(null); } } else { // Existe un punto en el valor literal if (operando1.indexOf(".") != -1) { return null; } criterioDto.setLiteralIzq(devolverOperandoLiteral(operando1)); criterioDto.setStrLiteralIzq(null); } } if (criterioDto.getTipoOperandoIzq().equals(TipoOperandoCriterioEmun.CRITERIO)) criterioDto.setIdCriterioIzq(guardaCriterio(operando1, tipoColumna, errores).getId()); // operando derecho if (!operacion.equals(TipoOperacionCriterioEmun.NOT)) { String operando2 = eliminarParentesisRedundantesExternos(trozos.get(2)); criterioDto.setTipoOperandoDch(identificarTipoOperando(operando2)); if (criterioDto.getTipoOperandoDch().equals(TipoOperandoCriterioEmun.LITERAL)) { if (esCadena(operando2)) { if (TipoAtributoFD.VALORFDNUMERICO.getDescripcion().equals(tipoColumna)) { errores.setHashErrors(true); EncapsuladorErrorSW error = new EncapsuladorErrorSW(); errores.getListaErrores().add(error); return null; } else { criterioDto.setStrLiteralDch(operando2.substring(1, operando2.length() - 1)); criterioDto.setLiteralDch(null); } } else { // Existe un punto en el valor literal if (operando2.indexOf(".") != -1) { return null; } criterioDto.setLiteralDch(devolverOperandoLiteral(operando2)); criterioDto.setStrLiteralDch(null); } } if (criterioDto.getTipoOperandoDch().equals(TipoOperandoCriterioEmun.CRITERIO)) criterioDto.setIdCriterioDch(guardaCriterio(operando2, tipoColumna, errores).getId()); } else { criterioDto.setTipoOperandoDch(TipoOperandoCriterioEmun.SIN_OPERANDO); } return guarda(criterioDto, errores); } catch (Throwable e) { LOG.error(e.getMessage()); return null; } }
public Boolean cargaEvaluacionCriterioTexto(CriterioDto criterioDto, String valor) throws Exception { return operaTexto(criterioDto, valor, TipoOperacionCriterioEmun.getComparaciones()); }
public Boolean cargaEvaluacionCriterio(CriterioDto criterioDto, Double valor) throws Exception { return opera(criterioDto, valor, TipoOperacionCriterioEmun.getComparaciones()); }