public static void tablatablaFirmantesEspera(Long idRegistro) {

    Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
    SolicitudGenerica dbSolicitud =
        SolicitudPresentarModificacionFAPController.getSolicitudGenerica(ids.get("idSolicitud"));
    Long idRegistroModificacion =
        dbSolicitud.registroModificacion.get(dbSolicitud.registroModificacion.size() - 1).id;
    RegistroModificacion registroModificacion =
        RegistroModificacion.findById(idRegistroModificacion);
    idRegistro = registroModificacion.registro.id;

    java.util.List<Firmante> rows =
        Firmante.find(
                "select firmante from Registro registro join registro.firmantes.todos firmante where registro.id=? and firmante.tipo=? and firmante.fechaFirma is not null",
                idRegistro,
                "representante")
            .fetch();

    List<Firmante> rowsFiltered = rows; // Tabla sin permisos, no filtra

    tables.TableRenderResponse<Firmante> response =
        new tables.TableRenderResponse<Firmante>(
            rowsFiltered, false, false, false, "", "", "", getAccion(), ids);

    renderJSON(response.toJSON("idvalor", "nombre", "id"));
  }
  public static void index(Long idEvaluacion, String accion) {
    Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
    if (secure.checkGrafico("accesoEvaluacion", "visible", "leer", ids, null)) {
      TipoEvaluacion tipoEvaluacion = TipoEvaluacion.all().first();
      Evaluacion evaluacion = Evaluacion.findById(idEvaluacion);
      if (evaluacion != null) {
        BaremacionUtils.ordenarTiposCEconomicos(evaluacion.tipo.ceconomicos);
        BaremacionUtils.ordenarCEconomicos(evaluacion.ceconomicos);
        BaremacionUtils.ordenarTiposCriterios(evaluacion.tipo.criterios);
        BaremacionUtils.ordenarCriterios(evaluacion.criterios);
      }
      notFoundIfNull(evaluacion);
      String expedienteUrl = redirectToFirstPage(evaluacion.solicitud.id);
      int duracion = tipoEvaluacion.duracion - 1;
      // Stupid hack
      boolean admin = "administradorgestor".contains(AgenteController.getAgente().rolActivo);

      if (!EstadosEvaluacionEnum.evaluada.name().equals(evaluacion.estado)) {
        BaremacionService.calcularTotales(evaluacion, admin, true);
      }
      boolean puedoGuardar =
          secure.checkGrafico("guardarEvaluacion", "editable", accion, ids, null);
      renderTemplate(
          "fap/Baremacion/fichaEvaluador.html",
          evaluacion,
          expedienteUrl,
          duracion,
          idEvaluacion,
          accion,
          puedoGuardar);
    } else {
      play.Logger.error("No se cumple el permiso \"accesoEvaluacion\" con ids: " + ids);
      forbidden();
    }
  }
  @Util
  public static void firmarRepresentanteFormFirmaRepresentante(
      Long idSolicitud, Long idRegistroModificacion, Long idRegistro, String firma) {
    SolicitudGenerica solicitud =
        SolicitudPresentarModificacionFAPController.getSolicitudGenerica(idSolicitud);
    idRegistroModificacion =
        solicitud.registroModificacion.get(solicitud.registroModificacion.size() - 1).id;
    RegistroModificacion registroModificacion =
        RegistroModificacion.findById(idRegistroModificacion);
    idRegistro = registroModificacion.registro.id;
    Registro registro =
        SolicitudPresentarModificacionFAPController.getRegistro(idRegistroModificacion, idRegistro);

    play.Logger.info("Metodo: firmarRepresentanteFormFirmaRepresentante");
    Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
    Map<String, Object> vars = new HashMap<String, Object>();
    if (secure.checkAcceso("editarFirma", "editar", ids, vars)) {
      if (registro.firmantes.todos == null || registro.firmantes.todos.size() == 0) {
        registro.firmantes.todos = solicitud.solicitante.calcularFirmantes();
        registro.firmantes.save();
      }
      FirmaUtils.firmar(registro.oficial, registro.firmantes.todos, firma, null);
    } else {
      // ERROR
      Messages.error("No tiene permisos suficientes para realizar la acción++");
    }
    if (!Messages.hasErrors()) {
      registro.fasesRegistro.firmada = true;
      registroModificacion.save();
      registro.save();
    }
  }
Ejemplo n.º 4
0
  @Util
  public static void PopupPassValidateCopy(String accion, Agente dbAgente, Agente agente) {
    CustomValidation.clearValidadas();
    if (secure.checkGrafico(
        "noEditable",
        "editable",
        accion,
        (Map<String, Long>) tags.TagMapStack.top("idParams"),
        null)) {
      CustomValidation.valid("agente", agente);
      dbAgente.username = agente.username;
    }

    CustomValidation.valid("agente", agente);
    CustomValidation.required("agente.verificacion", agente.verificacion);
    CustomValidation.required("agente.newpassword", agente.newpassword);
    CustomValidation.compare(agente.newpassword, params.get("agente_newpasswordcopy"));

    if (agente.verificacion != null) { // agente.verificación = contraseña actual
      if (dbAgente.password.equals(Crypto.passwordHash(agente.verificacion))) {
        dbAgente.password = Crypto.passwordHash(agente.newpassword);
        log.info("El usuario <" + dbAgente.username + "> ha modificado su contraseña");
      } else {
        Validation.addError("password", "Contraseña actual incorrecta");
      }
    }
    //		else {
    //			dbAgente.password = Crypto.passwordHash(agente.newpassword);
    //			log.info("El usuario <" + dbAgente.username + "> ha modificado su contraseña");
    //		}
  }
  public static void tabladocumentosAccesiblesEvaluador(Long idSolicitud, Long idEvaluacion) {

    java.util.List<Documento> rows = new ArrayList<Documento>();
    Evaluacion evaluacion = Evaluacion.findById(idEvaluacion);
    if (TipoDocumentoAccesible.count() > 0) {
      List<TipoDocumentoAccesible> tiposDocumentosAccesibles = TipoDocumentoAccesible.findAll();
      boolean encontrado;
      SolicitudGenerica dbSolicitud = SolicitudGenerica.findById(idSolicitud);
      List<Documento> documentosAportados =
          (List<Documento>)
              ModelUtils.invokeMethodClassStatic(
                  BaremacionFAP.class, "getDocumentosAccesibles", idSolicitud, idEvaluacion);
      for (TipoDocumentoAccesible tipo : tiposDocumentosAccesibles) {
        encontrado = false;
        for (int i = dbSolicitud.verificaciones.size() - 1; i >= 0; i--) {
          for (VerificacionDocumento documento : dbSolicitud.verificaciones.get(i).documentos) {
            if ((ObligatoriedadDocumentosFap.eliminarVersionUri(documento.uriTipoDocumento)
                    .equals(ObligatoriedadDocumentosFap.eliminarVersionUri(tipo.uri)))
                && (documento.estadoDocumentoVerificacion.equals(
                    EstadosDocumentoVerificacionEnum.valido.name()))) {
              if (documentosAportados != null) {
                for (Documento doc : documentosAportados) {
                  if ((doc.uri != null) && (doc.uri.equals(documento.uriDocumento))) {
                    rows.add(doc);
                    encontrado = true;
                    // break;
                  }
                }
              } else {
                play.Logger.error(
                    "No existe ningun documento en la lista de documentos Accesibles para buscar los del tipo requerido en la Evaluación.");
              }
              // break;
            }
          }
          //					if (encontrado)
          //						break;
        }
      }
    }
    // Siempre se añade el documento solicitud evaluación
    if (evaluacion.solicitudEnEvaluacion.uri != null) rows.add(evaluacion.solicitudEnEvaluacion);

    Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
    List<Documento> rowsFiltered = rows; // Tabla sin permisos, no filtra

    tables.TableRenderResponse<Documento> response =
        new tables.TableRenderResponse<Documento>(
            rowsFiltered, false, false, false, "", "", "", "editar", ids);

    renderJSON(response.toJSON("fechaRegistro", "descripcionVisible", "tipo", "urlDescarga", "id"));
  }
  @Util
  public static void save(Long idEvaluacion) {
    Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
    if (secure.checkGrafico("guardarEvaluacion", "editable", "editar", ids, null)) {
      boolean actionSave = params.get("save") != null;
      boolean actionPdf = params.get("pdf") != null;
      boolean actionEnd = params.get("end") != null;
      if (!(actionSave || actionPdf || actionEnd)) {
        // No se específico una acción
        notFound("Acción no especificada");
      }
      Evaluacion evaluacion = Evaluacion.findById(params.get("evaluacion.id", Long.class));
      if (evaluacion == null) {
        notFound("Fallo al recuperar la evaluación");
      }
      if (!evaluacion.estado.equals(EstadosEvaluacionEnum.enTramite.name())) {
        Messages.error("No se puede guardar porque esta evaluación ya ha sido finalizada");
        Messages.keep();
        index(evaluacion.id, "leer");
      }
      // Comentarios
      if (evaluacion.tipo.comentariosAdministracion) {
        evaluacion.comentariosAdministracion = params.get("evaluacion.comentariosAdministracion");
      }

      if (evaluacion.tipo.comentariosSolicitante) {
        evaluacion.comentariosSolicitante = params.get("evaluacion.comentariosSolicitante");
      }
      boolean guardarMaximo = false;
      // Criterios de evaluacion
      for (Criterio criterio : evaluacion.criterios) {
        String param = "criterio[" + criterio.id + "]";
        String key = param + ".valor";
        Double valor = params.get(key, Double.class);

        if (criterio.tipo.claseCriterio.equals("manual")
            || criterio.tipo.claseCriterio.equals("automod")) {

          // Únicamente valida cuando se va a finalizar
          // la verificación
          if (actionEnd || actionSave) {
            if (actionEnd) validation.required(key, valor);
            // TODO validaciones de tamaño máximo
            if (criterio.tipo.valorMaximo != null
                && valor != null
                && criterio.tipo.valorMaximo.compareTo(valor) < 0) {
              // validation.addError(key, "El valor "+valor+" es superior al valor máximo permitido:
              // "+criterio.tipo.valorMaximo);
              Messages.warning(
                  "El valor del criterio manual '"
                      + criterio.tipo.jerarquia
                      + " - "
                      + criterio.tipo.nombre
                      + "' ("
                      + FapFormat.formatMoneda(valor)
                      + ") es superior al permitido en ese tipo de criterio: "
                      + FapFormat.formatMoneda(criterio.tipo.valorMaximo));
              if (actionEnd) {
                criterio.valor = criterio.tipo.valorMaximo;
                guardarMaximo = true;
              }
            }
            if (criterio.tipo.valorMinimo != null
                && valor != null
                && criterio.tipo.valorMinimo.compareTo(valor) > 0) {
              Messages.warning(
                  "El criterio manual/automod "
                      + criterio.tipo.jerarquia
                      + " ("
                      + FapFormat.formatMoneda(valor)
                      + ") no llega al mínimo valor permitido: "
                      + criterio.tipo.valorMinimo
                      + ". Se ha establecido como valor a 0,00");
              if (actionEnd) criterio.valor = 0.0;
            }
          }
          if (!validation.hasErrors()) {
            if (guardarMaximo) guardarMaximo = false;
            else criterio.valor = valor;
          }
        }

        if (!validation.hasErrors()) {
          // Comentarios
          if (criterio.tipo.comentariosAdministracion) {
            criterio.comentariosAdministracion = params.get(param + ".comentariosAdministracion");
          }

          if (criterio.tipo.comentariosSolicitante) {
            criterio.comentariosSolicitante = params.get(param + ".comentariosSolicitante");
          }
        }
      }
      if (!validation.hasErrors()) {
        boolean admin = "administradorgestor".contains(AgenteController.getAgente().rolActivo);
        BaremacionService.calcularTotales(evaluacion, admin);
        for (Criterio criterio : evaluacion.criterios) {
          if (criterio.tipo.claseCriterio.equals("auto")) {
            if (actionEnd || actionSave) {
              if (criterio.tipo.valorMaximo != null
                  && criterio.valor != null
                  && criterio.tipo.valorMaximo.compareTo(criterio.valor) < 0) {
                if (actionSave)
                  Messages.warning(
                      "El criterio automático '"
                          + criterio.tipo.jerarquia
                          + " - "
                          + criterio.tipo.nombre
                          + "' ("
                          + FapFormat.formatMoneda(criterio.valor)
                          + ") sobrepasaba el máximo valor permitido. Se ha establecido como valor, su valor máximo posible: "
                          + FapFormat.formatMoneda(criterio.tipo.valorMaximo));
                criterio.valor = criterio.tipo.valorMaximo;
              }
              if (criterio.tipo.valorMinimo != null
                  && criterio.valor != null
                  && criterio.tipo.valorMinimo.compareTo(criterio.valor) > 0) {
                Messages.warning(
                    "El criterio automático "
                        + criterio.tipo.jerarquia
                        + " ("
                        + criterio.valor
                        + ") no llega al mínimo valor permitido: "
                        + FapFormat.formatMoneda(criterio.tipo.valorMinimo)
                        + ". Se ha establecido como valor a 0,00");
                criterio.valor = 0.0;
              }
            }
          }
        }
        if (!Messages.hasErrors()) {
          BaremacionService.calcularTotales(evaluacion, true, true);
        }
        evaluacion.save();
      } else {
        flash(evaluacion);
      }

      if (actionSave || actionEnd) {
        if (actionEnd && !validation.hasErrors()) {
          // Si no hubo errores anteriores, se comprueba si existen validaciones propias de la
          // aplicacion
          botonFinalizar();
          if (!Messages.hasErrors()) {
            evaluacion.estado = EstadosEvaluacionEnum.evaluada.name();
            evaluacion.save();
            Messages.ok(
                "La evaluación del expediente "
                    + evaluacion.solicitud.expedienteAed.idAed
                    + " finalizó correctamente");
            ConsultarEvaluacionesController.index();
          }
        }

        if (actionSave && !validation.hasErrors()) {
          Messages.ok(
              "La evaluación del expediente "
                  + evaluacion.solicitud.expedienteAed.idAed
                  + " se guardó correctamente");
        }

        Messages.keep();
        redirect("fap.FichaEvaluadorController.index", evaluacion.id, "editar");
      }
    } else {
      play.Logger.error("No se cumple el permiso \"guardarEvaluacion\" con ids: " + ids);
      forbidden();
    }
  }
  @Util
  public static void guardarPCEValidateCopy(
      String accion,
      CEconomicosManuales dbCEconomicosManuales,
      CEconomicosManuales cEconomicosManuales) {
    CustomValidation.clearValidadas();
    if (secure.checkGrafico(
        "modificacionTrasPresentacionDeSolicitud",
        "editable",
        accion,
        (Map<String, Long>) tags.TagMapStack.top("idParams"),
        null)) {
      CustomValidation.valid("cEconomicosManuales", cEconomicosManuales);

      // Código de Copia
      // (1) Caso de modificacion (Existe y lo cambio) (2) Caso de Creacion (Lo creo desde 0)

      String idSolicitud = params.get("idSolicitud");
      SolicitudGenerica dbSolicitud = SolicitudGenerica.findById(Long.parseLong(idSolicitud));

      PeticionModificacion peticionModificacion = new PeticionModificacion();
      peticionModificacion.campoPagina = "Solicitud.ceconomicos.otros";

      Map<String, String> allSimpleTabla = params.allSimple();
      for (Map.Entry<String, String> entry : allSimpleTabla.entrySet()) {
        if (entry.getKey().startsWith("id")) {
          try {
            peticionModificacion.idSimples.put(entry.getKey(), Long.parseLong(entry.getValue()));
          } catch (Exception e) {
            // El parámetro no era un long
          }
        }
      }
      peticionModificacion.idSimples.put("idCEconomicosManuales", dbCEconomicosManuales.id);
      List<String> valoresAntiguos = new ArrayList<String>();
      List<String> valoresNuevos = new ArrayList<String>();
      Boolean hayModificaciones = false;

      // Validando el tipo.nombre
      CustomValidation.valid("cEconomicosManuales.tipo", cEconomicosManuales.tipo);
      CustomValidation.required("cEconomicosManuales.tipo.nombre", cEconomicosManuales.tipo.nombre);

      // Código de Copia del tipo.nombre
      if (((dbCEconomicosManuales.tipo.nombre != null)
              && (cEconomicosManuales.tipo.nombre.toString() != null)
              && (!dbCEconomicosManuales
                  .tipo
                  .nombre
                  .toString()
                  .equals(cEconomicosManuales.tipo.nombre.toString())))
          || ((cEconomicosManuales.tipo.nombre == null)
              && (!cEconomicosManuales.tipo.nombre.equals(dbCEconomicosManuales.tipo.nombre)))) {
        valoresAntiguos = new ArrayList<String>();
        if (dbCEconomicosManuales.tipo.nombre != null)
          valoresAntiguos.add(dbCEconomicosManuales.tipo.nombre.toString());
        valoresNuevos = new ArrayList<String>();
        valoresNuevos.add(cEconomicosManuales.tipo.nombre.toString());
        peticionModificacion.setValorModificado(
            "Solicitud.ceconomicos.otros.tipo.nombre", valoresAntiguos, valoresNuevos);
        hayModificaciones = true;
      }
      dbCEconomicosManuales.tipo.nombre = cEconomicosManuales.tipo.nombre;

      // Código de Copia del tipo.descripcion
      if (((dbCEconomicosManuales.tipo.descripcion != null)
              && (cEconomicosManuales.tipo.descripcion.toString() != null)
              && (!dbCEconomicosManuales
                  .tipo
                  .descripcion
                  .toString()
                  .equals(cEconomicosManuales.tipo.descripcion.toString())))
          || ((cEconomicosManuales.tipo.descripcion == null)
              && (!cEconomicosManuales.tipo.descripcion.equals(
                  dbCEconomicosManuales.tipo.descripcion)))) {
        valoresAntiguos = new ArrayList<String>();
        if (dbCEconomicosManuales.tipo.descripcion != null)
          valoresAntiguos.add(dbCEconomicosManuales.tipo.descripcion.toString());
        valoresNuevos = new ArrayList<String>();
        valoresNuevos.add(cEconomicosManuales.tipo.descripcion.toString());
        peticionModificacion.setValorModificado(
            "Solicitud.ceconomicos.otros.tipo.descripcion", valoresAntiguos, valoresNuevos);
        hayModificaciones = true;
      }
      dbCEconomicosManuales.tipo.descripcion = cEconomicosManuales.tipo.descripcion;

      // Código de Copia del comentarioAdministracion
      if (((dbCEconomicosManuales.comentariosAdministracion != null)
              && (cEconomicosManuales.comentariosAdministracion.toString() != null)
              && (!dbCEconomicosManuales
                  .comentariosAdministracion
                  .toString()
                  .equals(cEconomicosManuales.comentariosAdministracion.toString())))
          || ((cEconomicosManuales.comentariosAdministracion == null)
              && (!cEconomicosManuales.comentariosAdministracion.equals(
                  dbCEconomicosManuales.comentariosAdministracion)))) {
        valoresAntiguos = new ArrayList<String>();
        if (dbCEconomicosManuales.comentariosAdministracion != null)
          valoresAntiguos.add(dbCEconomicosManuales.comentariosAdministracion.toString());
        valoresNuevos = new ArrayList<String>();
        valoresNuevos.add(cEconomicosManuales.comentariosAdministracion.toString());
        peticionModificacion.setValorModificado(
            "Solicitud.ceconomicos.otros.comentariosAdministracion",
            valoresAntiguos,
            valoresNuevos);
        hayModificaciones = true;
      }
      dbCEconomicosManuales.comentariosAdministracion =
          cEconomicosManuales.comentariosAdministracion;

      // Código de Copia del comentarioSolicitante
      if (((dbCEconomicosManuales.comentariosSolicitante != null)
              && (cEconomicosManuales.comentariosSolicitante.toString() != null)
              && (!dbCEconomicosManuales
                  .comentariosSolicitante
                  .toString()
                  .equals(cEconomicosManuales.comentariosSolicitante.toString())))
          || ((cEconomicosManuales.comentariosSolicitante == null)
              && (!cEconomicosManuales.comentariosSolicitante.equals(
                  dbCEconomicosManuales.comentariosSolicitante)))) {
        valoresAntiguos = new ArrayList<String>();
        if (dbCEconomicosManuales.comentariosSolicitante != null)
          valoresAntiguos.add(dbCEconomicosManuales.comentariosSolicitante.toString());
        valoresNuevos = new ArrayList<String>();
        valoresNuevos.add(cEconomicosManuales.comentariosSolicitante.toString());
        peticionModificacion.setValorModificado(
            "Solicitud.ceconomicos.otros.comentariosSolicitante", valoresAntiguos, valoresNuevos);
        hayModificaciones = true;
      }
      dbCEconomicosManuales.comentariosSolicitante = cEconomicosManuales.comentariosSolicitante;

      // Guardo en el json los valores simples:
      // Json por todos los valores
      if (hayModificaciones) {
        // peticionModificacion.setValorModificado("Solicitud.ceconomicos.otros", valoresAntiguos,
        // valoresNuevos);
        peticionModificacion.idSimples.put("idCEconomicosManuales", dbCEconomicosManuales.id);
        Gson gson = new Gson();
        String jsonPM = gson.toJson(peticionModificacion);
        JsonPeticionModificacion jsonPeticionModificacion = new JsonPeticionModificacion();
        jsonPeticionModificacion.jsonPeticion = jsonPM;
        dbSolicitud
            .registroModificacion
            .get(dbSolicitud.registroModificacion.size() - 1)
            .jsonPeticionesModificacion
            .add(jsonPeticionModificacion);
        dbSolicitud.save();
      }

      // Copia de los valores: O2M Un json por cada valor

      // Logica de copia a BBDD
      List<String> valoresAntiguosTabla = new ArrayList<String>();
      List<String> valoresNuevosTabla = new ArrayList<String>();

      if ((dbCEconomicosManuales.valores == null)
          || (dbCEconomicosManuales.valores.size() == 0)) { // Dead code?
        // peticionModificacion.idSimples.put("idCEconomicosManuales",dbCEconomicosManuales.id);
        // //Viernes añadido
        // Guardo todos los nuevos valores
        for (int i = 0; i < cEconomicosManuales.valores.size(); i++) { // Modificando
          valoresNuevosTabla = new ArrayList<String>();
          valoresNuevosTabla.add(cEconomicosManuales.valores.get(i).valorSolicitado.toString());

          // Json por todos los valores
          PeticionModificacion peticionModificacionTabla = new PeticionModificacion();
          peticionModificacionTabla.campoPagina =
              "Solicitud.ceconomicos.otros.valores.valorSolicitado";
          peticionModificacionTabla.idSimples = peticionModificacion.idSimples;
          peticionModificacionTabla.idSimples.put(
              "idValoresCEconomicoManuales", cEconomicosManuales.valores.get(i).id);

          peticionModificacionTabla.setValorCreado(
              "Solicitud.ceconomicos.otros.valores.valorSolicitado",
              new ArrayList<String>(),
              valoresNuevosTabla); // PRUEBA
          Gson gsonTabla = new Gson();
          String jsonPMTabla = gsonTabla.toJson(peticionModificacionTabla);
          JsonPeticionModificacion jsonPeticionModificaciontabla = new JsonPeticionModificacion();
          jsonPeticionModificaciontabla.jsonPeticion = jsonPMTabla;
          dbSolicitud
              .registroModificacion
              .get(dbSolicitud.registroModificacion.size() - 1)
              .jsonPeticionesModificacion
              .add(jsonPeticionModificaciontabla);
          dbSolicitud.save();
        }
        dbCEconomicosManuales.valores = cEconomicosManuales.valores;

      } else {
        for (int i = 0; i < cEconomicosManuales.valores.size(); i++) { // Modificando
          valoresAntiguosTabla = new ArrayList<String>();
          valoresNuevosTabla = new ArrayList<String>();
          hayModificaciones = false;

          PeticionModificacion peticionModificacionTabla = new PeticionModificacion();
          peticionModificacionTabla.campoPagina =
              "Solicitud.ceconomicos.otros.valores.valorSolicitado";
          peticionModificacionTabla.idSimples = peticionModificacion.idSimples;

          if ((cEconomicosManuales.valores.get(i).valorSolicitado != null)
              && (cEconomicosManuales.valores.get(i).valorSolicitado.toString()
                  != dbCEconomicosManuales.valores.get(i).valorSolicitado.toString())) {
            valoresAntiguosTabla.add(
                dbCEconomicosManuales.valores.get(i).valorSolicitado.toString());
            dbCEconomicosManuales.valores.get(i).valorSolicitado =
                cEconomicosManuales.valores.get(i).valorSolicitado; // Logica
            valoresNuevosTabla.add(cEconomicosManuales.valores.get(i).valorSolicitado.toString());
            peticionModificacionTabla.idSimples.put(
                "idValoresCEconomico",
                dbCEconomicosManuales.valores.get(i).id); // AQUI idValoresCEconomo

            // Json
            peticionModificacionTabla.setValorModificado(
                "Solicitud.ceconomicos.otros.valores.valorSolicitado",
                valoresAntiguosTabla,
                valoresNuevosTabla); // PRUEBA
            Gson gsonTabla = new Gson();
            String jsonPMTabla = gsonTabla.toJson(peticionModificacionTabla);
            JsonPeticionModificacion jsonPeticionModificaciontabla = new JsonPeticionModificacion();
            jsonPeticionModificaciontabla.jsonPeticion = jsonPMTabla;
            dbSolicitud
                .registroModificacion
                .get(dbSolicitud.registroModificacion.size() - 1)
                .jsonPeticionesModificacion
                .add(jsonPeticionModificaciontabla);
            dbSolicitud.save();
          }
        }
      }
      // dbCEconomicosManuales.valores=cEconomicosManuales.valores;
    }
  }