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());
 }
Esempio n. 10
0
 public Boolean cargaEvaluacionCriterio(CriterioDto criterioDto, Double valor) throws Exception {
   return opera(criterioDto, valor, TipoOperacionCriterioEmun.getComparaciones());
 }