Exemplo n.º 1
0
  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");
  }
Exemplo n.º 2
0
  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");
  }
Exemplo n.º 3
0
  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;
  }
Exemplo n.º 4
0
  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;
  }
Exemplo n.º 5
0
  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;
  }
Exemplo n.º 6
0
  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");
  }
Exemplo n.º 7
0
  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;
    }
  }