Crear una bitácora de cambios de estado de las actividades
BITACORA_AM
ACTIVIDAD_MEJORA
ESTADO_AM
FECHA
USUARIO
Justificación
Crear pestaña que contenga una tabla que muestre la bitácora de la actividad.
Ordenado por fecha DES
Asignarles el estado en proceso a todos los registros (En proceso).
Agregar autocomplete para la selección del estado.
Sólo se puede seleccionar manualmente los valores (Sin iniciar y Descartada)
Si se cambia el estado debe registrar la bitácora incluyendo la justificación.
Agregar área de texto (remaining)
Obligatoria para los cambios de estado.
Si se modifica la vigencia de la actividad se debe recalcular el estado con respecto al avance o cumplimiento de la meta operativa de la siguiente manera:
En proceso, si el cálculo del avance o cumplimiento es inferior a 100%
Implementada, si el cálculo del avance o cumplimiento es 100%
Debe registrar la bitácora incluyendo la justificación.
El usuario administrador del módulo MCG puede seleccionar el estado Descartada, para lo cual debe adjuntar un oficio y digitar la justificación de manera obligatoria.
Al descartar una actividad pasa a estar inactivo el registro.
Cuando el avance y/o cumplimiento de los planes operativos obtengan el estado APROBADO por unidad integradora o en un sólo nivel se debe recalcular el estado de las actividades de mejora y de respuesta al riesgo con respecto al avance o cumplimiento de la meta operativa de la siguiente manera:
En proceso, si el cálculo del avance o cumplimiento es inferior a 100%
Implementada, si el cálculo del avance o cumplimiento es 100%
Debe crear un registro en la bitácora de AM
Estado calculado en esta tarea
Usuario, debe registrar el que cambió el avance o cumplimiento a los estados Aprobado Unidad Integradora o Aprobado en un sólo nivel.
Fecha, debe registrar la fecha de aprobación (APROBADO por unidad integradora o en un sólo nivel) del avance o cumplimiento.
Justificación de la META_POA asociada a la AM
TAREA: BITACORA AM
Crear una bitácora de cambios de estado de las actividades
BITACORA_AM
ACTIVIDAD_MEJORA
ESTADO_AM
FECHA
USUARIO
Justificación
Crear pestaña que contenga una tabla que muestre la bitácora de la actividad.
Ordenado por fecha DES
Asignarles el estado en proceso a todos los registros (En proceso).
Agregar autocomplete para la selección del estado.
Sólo se puede seleccionar manualmente los valores (Sin iniciar y Descartada)
Si se cambia el estado debe registrar la bitácora incluyendo la justificación.
Agregar área de texto (remaining)
Obligatoria para los cambios de estado.
Si se modifica la vigencia de la actividad se debe recalcular el estado con respecto al avance o cumplimiento de la meta operativa de la siguiente manera:
En proceso, si el cálculo del avance o cumplimiento es inferior a 100%
Implementada, si el cálculo del avance o cumplimiento es 100%
Debe registrar la bitácora incluyendo la justificación.
El usuario administrador del módulo MCG puede seleccionar el estado Descartada, para lo cual debe adjuntar un oficio y digitar la justificación de manera obligatoria.
Al descartar una actividad pasa a estar inactivo el registro.
Cuando el avance y/o cumplimiento de los planes operativos obtengan el estado APROBADO por unidad integradora o en un sólo nivel se debe recalcular el estado de las actividades de mejora y de respuesta al riesgo con respecto al avance o cumplimiento de la meta operativa de la siguiente manera:
En proceso, si el cálculo del avance o cumplimiento es inferior a 100%
Implementada, si el cálculo del avance o cumplimiento es 100%
Debe crear un registro en la bitácora de AM
Estado calculado en esta tarea
Usuario, debe registrar el que cambió el avance o cumplimiento a los estados Aprobado Unidad Integradora o Aprobado en un sólo nivel.
Fecha, debe registrar la fecha de aprobación (APROBADO por unidad integradora o en un sólo nivel) del avance o cumplimiento.
Justificación de la META_POA asociada a la AM
Creación de Bitacora
Como se ve vamos a crear 2 bitacoras una ARR (Actividad Respuesta al Riesgo) y otra AM (Actividad Mejora)
Por lo que creamos los script de creación
BitacoraARRCreate.sql
/*
* Copyright (C) 2022.
*
* Centro de Gestion Informatica
* Direccion de Tecnologias de la Informacion y Comunicacion
* Universidad Nacional - Costa Rica
* http://www.una.ac.cr
*
* Author: Gustavo Matamoros González
* Created: 11/04/2023
*/
/********************************************************/
/* CREACIÓN DE TABLA */
/********************************************************/
CREATE TABLE "PPI"."BITACORA_ARR"
(
"ID_BITACORA_ARR" NUMBER (19,0) NOT NULL ENABLE,
"ACTIVIDAD_RIESGO" NUMBER (19,0) NOT NULL ENABLE,
"ESTADO_ARR" NUMBER (19,0) NOT NULL ENABLE,
"USUARIO" NUMBER (19,0) NOT NULL ENABLE,
"FECHA" DATE NOT NULL ENABLE,
"JUSTIFICACION" VARCHAR2(500 BYTE),
"FECHA_CREACION" DATE NOT NULL ENABLE,
"USUARIO_CREACION" NUMBER(19,0) NOT NULL ENABLE,
"FECHA_MODIFICACION" DATE NOT NULL ENABLE,
"USUARIO_MODIFICACION" NUMBER(19,0) NOT NULL ENABLE,
"VERSION" NUMBER(19,0),
"CAMPO_CONFIGURABLE" NUMBER(19,0),
CONSTRAINT "PK_BITACORA_ARR" PRIMARY KEY("ID_BITACORA_ARR"),
/********************************************************/
/* LLAVE: FORANEAS */
/********************************************************/
--BITACORA_ARR->ACTIVIDAD_RESPUESTA_RIESGO
CONSTRAINT FK_BIT_ARR_ARR FOREIGN KEY(ACTIVIDAD_RIESGO) REFERENCES PPI.ACTIVIDAD_RESPUESTA_RIESGO(ID_ACTIVIDAD_RESPUESTA_RIESGO),
--BITACORA_ARR->ESTADO_ARR
CONSTRAINT FK_BIT_ARR_EST_ARR FOREIGN KEY(ESTADO_ARR) REFERENCES PPI.ESTADO_ARR(ID_ESTADO_ARR),
--BITACORA_ARR->USUARIO
CONSTRAINT FK_BIT_ARR_USU FOREIGN KEY(USUARIO) REFERENCES SAS.USUARIO (ID_USUARIO),
/********************************************************/
/* LLAVE: FORANEAS SIGESA */
/********************************************************/
CONSTRAINT FK_BIT_ARR_USU_CRE FOREIGN KEY(USUARIO_CREACION) REFERENCES SAS.USUARIO(ID_USUARIO),
CONSTRAINT FK_BIT_ARR_USU_MOD FOREIGN KEY(USUARIO_MODIFICACION) REFERENCES SAS.USUARIO(ID_USUARIO),
CONSTRAINT FK_BIT_ARR_CAM_CON FOREIGN KEY(CAMPO_CONFIGURABLE) REFERENCES SAS.CAMPO_CONFIGURABLE(ID_CAMPO_CONFIGURABLE)
);
/********************************************************/
/* COMENTARIOS */
/********************************************************/
COMMENT ON COLUMN "PPI"."BITACORA_ARR"."ACTIVIDAD_RIESGO" IS 'Campo que relaciona la tabla BITACORA_ARR con la tabla ACTIVIDAD_RESPUESTA_RIESGO';
COMMENT ON COLUMN "PPI"."BITACORA_ARR"."ESTADO_ARR" IS 'Campo que relaciona la tabla BITACORA_ARR con la tabla ESTADO_ARR';
COMMENT ON COLUMN "PPI"."BITACORA_ARR"."USUARIO" IS 'Campo que relaciona la tabla BITACORA_ARR con la tabla USUARIO';
COMMENT ON COLUMN "PPI"."BITACORA_ARR"."FECHA" IS 'Fecha y hora en que se realiza la transacción';
COMMENT ON COLUMN "PPI"."BITACORA_ARR"."JUSTIFICACION" IS 'Campo para almacenar la justificación de un cambio de estado de actividad';
/********************************************************/
/* SECUENCIA */
/********************************************************/
CREATE SEQUENCE PPI.SQ_BITACORA_ARR START WITH 1 INCREMENT BY 1 MINVALUE 1 NOCACHE NOCYCLE NOORDER;
/********************************************************/
/* SINONIMOS */
/********************************************************/
CREATE PUBLIC SYNONYM BITACORA_ARR FOR "PPI"."BITACORA_ARR";
CREATE PUBLIC SYNONYM SQ_BITACORA_ARR FOR PPI.SQ_BITACORA_ARR;
/********************************************************/
/* GRANT PERMISOS SOBRE LA TABLA */
/********************************************************/
GRANT DELETE, INSERT, UPDATE, SELECT, REFERENCES ON PPI.BITACORA_ARR TO WWW_SIGESA, WWW_TEUNA;
GRANT SELECT, ALTER ON PPI.SQ_BITACORA_ARR TO WWW_SIGESA, WWW_TEUNA;
GRANT SELECT ON "PPI"."BITACORA_ARR" TO "ANALISTA", "ANALISTA_SIGESA";
/********************************************************/
/* ELIMINAR TABLA (ROLLBACK) */
/********************************************************/
DROP SEQUENCE "PPI".SQ_BITACORA_ARR;
DROP PUBLIC SYNONYM BITACORA_ARR;
DROP PUBLIC SYNONYM SQ_BITACORA_ARR;
DROP TABLE "PPI".BITACORA_ARR;
BitacoraAMCreate.sql
/*
* Copyright (C) 2022.
*
* Centro de Gestion Informatica
* Direccion de Tecnologias de la Informacion y Comunicacion
* Universidad Nacional - Costa Rica
* http://www.una.ac.cr
*
* Author: Gustavo Matamoros González
* Created: 11/04/2023
*/
/********************************************************/
/* CREACIÓN DE TABLA */
/********************************************************/
CREATE TABLE "PPI"."BITACORA_AM"
(
"ID_BITACORA_AM" NUMBER (19,0) NOT NULL ENABLE,
"ACTIVIDAD_MEJORA" NUMBER (19,0) NOT NULL ENABLE,
"ESTADO_AM" NUMBER (19,0) NOT NULL ENABLE,
"USUARIO" NUMBER (19,0) NOT NULL ENABLE,
"FECHA" DATE NOT NULL ENABLE,
"JUSTIFICACION" VARCHAR2(500 BYTE),
"FECHA_CREACION" DATE NOT NULL ENABLE,
"USUARIO_CREACION" NUMBER(19,0) NOT NULL ENABLE,
"FECHA_MODIFICACION" DATE NOT NULL ENABLE,
"USUARIO_MODIFICACION" NUMBER(19,0) NOT NULL ENABLE,
"VERSION" NUMBER(19,0),
"CAMPO_CONFIGURABLE" NUMBER(19,0),
CONSTRAINT "PK_BITACORA_AM" PRIMARY KEY("ID_BITACORA_AM"),
/********************************************************/
/* LLAVE: FORANEAS */
/********************************************************/
--BITACORA_AM->ACTIVIDAD_MEJORA
CONSTRAINT FK_BIT_AM_AM FOREIGN KEY(ACTIVIDAD_MEJORA) REFERENCES PPI.ACTIVIDAD_MEJORA(ID_ACTIVIDAD_MEJORA),
--BITACORA_AM->ESTADO_AM
CONSTRAINT FK_BIT_AM_EST_AM FOREIGN KEY(ESTADO_AM) REFERENCES PPI.ESTADO_AM(ID_ESTADO_AM),
--BITACORA_AM->USUARIO
CONSTRAINT FK_BIT_AM_USU FOREIGN KEY(USUARIO) REFERENCES SAS.USUARIO (ID_USUARIO),
/********************************************************/
/* LLAVE: FORANEAS SIGESA */
/********************************************************/
CONSTRAINT FK_BIT_AM_USU_CRE FOREIGN KEY(USUARIO_CREACION) REFERENCES SAS.USUARIO(ID_USUARIO),
CONSTRAINT FK_BIT_AM_USU_MOD FOREIGN KEY(USUARIO_MODIFICACION) REFERENCES SAS.USUARIO(ID_USUARIO),
CONSTRAINT FK_BIT_AM_CAM_CON FOREIGN KEY(CAMPO_CONFIGURABLE) REFERENCES SAS.CAMPO_CONFIGURABLE(ID_CAMPO_CONFIGURABLE)
);
/********************************************************/
/* COMENTARIOS */
/********************************************************/
COMMENT ON COLUMN "PPI"."BITACORA_AM"."ACTIVIDAD_MEJORA" IS 'Campo que relaciona la tabla BITACORA_AM con la tabla ACTIVIDAD_MEJORA';
COMMENT ON COLUMN "PPI"."BITACORA_AM"."ESTADO_AM" IS 'Campo que relaciona la tabla BITACORA_AM con la tabla ESTADO_AM';
COMMENT ON COLUMN "PPI"."BITACORA_AM"."USUARIO" IS 'Campo que relaciona la tabla BITACORA_AM con la tabla USUARIO';
COMMENT ON COLUMN "PPI"."BITACORA_AM"."FECHA" IS 'Fecha y hora en que se realiza la transacción';
COMMENT ON COLUMN "PPI"."BITACORA_AM"."JUSTIFICACION" IS 'Campo para almacenar la justificación de un cambio de estado de actividad';
/********************************************************/
/* SECUENCIA */
/********************************************************/
CREATE SEQUENCE PPI.SQ_BITACORA_AM START WITH 1 INCREMENT BY 1 MINVALUE 1 NOCACHE NOCYCLE NOORDER;
/********************************************************/
/* SINONIMOS */
/********************************************************/
CREATE PUBLIC SYNONYM BITACORA_AM FOR "PPI"."BITACORA_AM";
CREATE PUBLIC SYNONYM SQ_BITACORA_AM FOR PPI.SQ_BITACORA_AM;
/********************************************************/
/* GRANT PERMISOS SOBRE LA TABLA */
/********************************************************/
GRANT DELETE, INSERT, UPDATE, SELECT, REFERENCES ON PPI.BITACORA_AM TO WWW_SIGESA, WWW_TEUNA;
GRANT SELECT, ALTER ON PPI.SQ_BITACORA_AM TO WWW_SIGESA, WWW_TEUNA;
GRANT SELECT ON "PPI"."BITACORA_AM" TO "ANALISTA", "ANALISTA_SIGESA";
/********************************************************/
/* ELIMINAR TABLA (ROLLBACK) */
/********************************************************/
DROP SEQUENCE "PPI".SQ_BITACORA_AM;
DROP PUBLIC SYNONYM BITACORA_AM;
DROP PUBLIC SYNONYM SQ_BITACORA_AM;
DROP TABLE "PPI".BITACORA_AM;
id=»ARR_TabView»: es un id que identifica el tabVieq
activeIndex=»#{actividadRespuestaRiesgoBean.activeTab}»: establece en el Bean cual es el tab inicial
ActividadRespuestaRiesgoBean.java
ACTIVEINDEX:
Como se ve dentro de ActividadRespuestaRiesgoBean.java en la función init(), se debe difinir cual es el número del tab inicial, com la siguiente instrucción
this.activeTab = 0;
Ahora este campo se encuentra definido por herencia de SIGESA dentro de «CRUDImpl»
Por tanto con solo que indiquemos el valor es suficiente
Con esto vamos a poder agregar los siguientes metodos
/**
* Metodo que obtiene el esatdo AM por tipo de parametro.
*
* @param parametro
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM segun parametro
*/
public EstadoAM findEstadoAMByParametro(Parametro parametro) {
try {
return findOne(Long.valueOf(parametro.getValor()));
} catch (Exception ex) {
return null;
}
}
/**
* Metodo que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMSinIniciar() {
return findEstadoAMByParametro(parametroService.findOneByLlave("param_ppi_mcg_actividadMejora_estado_sinIniciar"));
}
/**
* Metodo que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMEnProceso() {
return findEstadoAMByParametro(parametroService.findOneByLlave("param_ppi_mcg_actividadMejora_estado_enProceso"));
}
/**
* Metodo que obtiene el estado completado.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMCompletado() {
return findEstadoAMByParametro(parametroService.findOneByLlave("param_ppi_mcg_actividadMejora_estado_completado"));
}
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMImplementada() {
return findEstadoAMByParametro(parametroService.findOneByLlave("param_ppi_mcg_actividadMejora_estado_implementada"));
}
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMDescartada() {
return findEstadoAMByParametro(parametroService.findOneByLlave("param_ppi_mcg_actividadMejora_estado_descartada"));
}
EstadoAMService.java
Agregamos la definiciones
/**
* Definición que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMSinIniciar();
/**
* Definición que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMEnProceso();
/**
* Definición que obtiene el estado completado.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMCompletado();
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMImplementada();
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 19/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMDescartada();
Justificación
Ahora vamos a trabajar en la justificación
Esta justificación pertenece a la entidad Bitacora y no al propio objeto
Y va ser requerida cuando el usuario modifique el estado
por tanto dentro del Bean vamos a crear una bandera que detemine si el usuario a modificado o no el estado
ActividadRespuestaRiesgoBean.java
Agregamos
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** VARIABLES *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
// Variable para paso de parametros en LOV
private Map<String, Object> beanParams = new HashMap();
//variable que detemina si se modificó o no el estado
private Boolean existeCambioEstado;
//Variable que almacena la justificación de la Bitacora
private String justificacionBitacoraARR;
// Variable que almacena el estado Inicial para determinar si fue o no modificado
private EstadoARR estadoARRInicial;
// Variable para determinar si es una actividad nueva
private Boolean actividadNueva;
Ahora con estas variables debemos inicializarlas en initDetails
agregamos
// Si existe una entidad es una modificación
if(this.getEntity().getId() != null){
// obtenemos el estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// No es una actividad nueva
this.setActividadNueva(false);
//Es una actividad Nueva
}else{
this.setActividadNueva(true);
}
// Inicializamos la justificación de bitacora en vació
this.setJustificacionBitacoraARR("");
// Indicamos que no existe un cambio de estado
this.setExisteCambioEstado(false);
Quedando así
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public void initDetails() {
if (!isPostBack()) {
// Si existe una entidad es una modificación
if(this.getEntity().getId() != null){
// obtenemos el estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// No es una actividad nueva
this.setActividadNueva(false);
//Es una actividad Nueva
}else{
this.setActividadNueva(true);
}
// Inicializamos la justificación de bitacora en vació
this.setJustificacionBitacoraARR("");
// Indicamos que no existe un cambio de estado
this.setExisteCambioEstado(false);
// Inicializar la lista de bitacora
this.getEntity().setListaBitacoraARR(bitacoraARRBean.setDetails(this.getEntity().getListaBitacoraARR()));
bitacoraARRBean.init();
}
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
Ahora creamos la función que se va a encargar de de actulizar la variable ExistejCambioEstado
/**********************************************************************/
/**
* Función que actualiza el estado
* @author Gustavo Matamoros González
* @since 18/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioEstado(){
// Si es una actualización
if(this.estadoARRInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}else{
this.setExisteCambioEstado(true);
}
}else{
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
}
actividadRespuestaRiesgoEditForm.xhtml
Ahora vamos a agregar el código necesario para mostrar la justificación
Lo primero sería aplicar el siguiente código para cuando se seleccione un nuevo estado actualice la variable ExisteCambioEstado
Por tanto dentro de autoCompletePaginator agregamos
Ahora creamos la función que se va a encargar de de actualizar la variable ExisteCambioEstado
/**********************************************************************/
/**
* Función que actualiza el estado
* @author Gustavo Matamoros González
* @since 18/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioEstado(){
// Si es una actualización
if(this.estadoAMInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}else{
this.setExisteCambioEstado(true);
}
}else{
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}
}
actividadMejoraEditForm.xhtml
Ahora vamos a agregar el código necesario para mostrar la justificación
Lo primero sería aplicar el siguiente código para cuando se seleccione un nuevo estado actualice la variable ExisteCambioEstado
Por tanto dentro de autoCompletePaginator agregamos
Ahora vamos a iniciar en el proceso de crear un registro en bitacora
ActividadRespuestaRiesgoBean.java
Ahora vamos a crear un servicio que permita guardar un registro de bitacora y lo agrege a la lista
NOTA: como ARR contiene una lista de bitacora con solo agregar el registro a la lista al guardar se guardaran sus hijos
Pero tenemos la situación que la justificación o pertenece a la entidad si no como una variale del bean
Entonces para poder pasar al valor del Bean a Service debemos sobre escribir el método de update para indcarle que agregue a la lista y continue guardando
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
@Override
public String update(){
String form;
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraARRModificado(this.getEntity(), this.justificacionBitacoraARR);
form = super.update();
// Limpiamos la Justificación
if(!this.justificacionBitacoraARR.isEmpty()){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
return form;
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
Con esto estamos pasando la justificación del Bean al service
/**********************************************************************/
/**
* Función que crea un objetivo tipo BitacoraARR y lo agrega a listaBitacoraARR
* @author Gustavo Matamoros González
* @since 19/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void creaBitacoraARRModificado(ActividadRespuestaRiesgo actividadRespuestaRiesgo, String justificacion);
Y con esto al momento de actulizar se almacenará un registro en bitacora
ActividadMejoraBean.java
Ahora vamos a crear un servicio que permita guardar un registro de bitacora y lo agrege a la lista
NOTA: como AM contiene una lista de bitacora con solo agregar el registro a la lista al guardar se guardaran sus hijos
Pero tenemos la situación que la justificación o pertenece a la entidad si no como una variale del bean
Entonces para poder pasar al valor del Bean a Service debemos sobre escribir el método de update para indcarle que agregue a la lista y continue guardando
@Override
public String update(){
String form;
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraAMModificado(this.getEntity(), this.justificacionBitacoraAM);
form = super.update();
// Limpiamos la Justificación
if(!this.justificacionBitacoraAM.isEmpty()){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}
return form;
}
Con esto estamos pasando la justificación del Bean al service
Ahora debemos inidicarle al bean que utilice este campo en vez de la fecha
ASERColumn column2 = new ASERColumn("fecha", getI18n("bitacoraARR_fecha_label"), true);
X
ASERColumn column2 = new ASERColumn("fechaHora", getI18n("bitacoraARR_fecha_label"), true);
Ahora le indicamos que utlice este campo en vez de fecha
ASERColumn column2 = new ASERColumn("fecha", getI18n("bitacoraAM_fecha_label"), true);
X
ASERColumn column2 = new ASERColumn("fechaHora", getI18n("bitacoraAM_fecha_label"), true);
Ordenar Lista bitacora ASER por fecha DESC
Para ordenar la bitacora por fecha hora en forma desendente
// Odernar descendente l2 -> l1
final Comparator<BitacoraARR> ORDENAR_FECHA = new Comparator<BitacoraARR>() {
public int compare(BitacoraARR l1, BitacoraARR l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
Antes de la inicialización de la lista
// Inicializar la lista de bitacora
this.getEntity().setListaBitacoraARR(bitacoraARRBean.setDetails(this.getEntity().getListaBitacoraARR()));
bitacoraARRBean.init();
Quedando así
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public void initDetails() {
if (!isPostBack()) {
// Si existe una entidad es una modificación
if(this.getEntity().getId() != null){
// obtenemos el estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// No es una actividad nueva
this.setActividadNueva(false);
//Es una actividad Nueva
}else{
this.setActividadNueva(true);
}
// Inicializamos la justificación de bitacora en vació
this.setJustificacionBitacoraARR("");
// Indicamos que no existe un cambio de estado
this.setExisteCambioEstado(false);
// Odernar descendente l2 -> l1
final Comparator<BitacoraARR> ORDENAR_FECHA = new Comparator<BitacoraARR>() {
public int compare(BitacoraARR l1, BitacoraARR l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// Inicializar la lista de bitacora
this.getEntity().setListaBitacoraARR(bitacoraARRBean.setDetails(this.getEntity().getListaBitacoraARR()));
bitacoraARRBean.init();
}
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
// Odernar descendente l2 -> l1
final Comparator<BitacoraAM> ORDENAR_FECHA = new Comparator<BitacoraAM>() {
public int compare(BitacoraAM l1, BitacoraAM l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
if (this.getEntity().getListaBitacoraAM() != null) {
Collections.sort(this.getEntity().getListaBitacoraAM(), ORDENAR_FECHA);
}
Final
public void initDetails() {
if (!isPostBack()) {
if(this.getEntity().getId() != null){
this.estadoAMInicial = this.getEntity().getEstadoAM();
this.setActividadNueva(false);
}else{
this.setActividadNueva(true);
}
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
// Odernar descendente l2 -> l1
final Comparator<BitacoraAM> ORDENAR_FECHA = new Comparator<BitacoraAM>() {
public int compare(BitacoraAM l1, BitacoraAM l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
if (this.getEntity().getListaBitacoraAM() != null) {
Collections.sort(this.getEntity().getListaBitacoraAM(), ORDENAR_FECHA);
}
this.getEntity().setListaBitacoraAM(bitacoraAMBean.setDetails(this.getEntity().getListaBitacoraAM()));
bitacoraAMBean.init();
}
}
Actualización:
En este punto se corrigueron varios errores de programación por lo que se corrigen
ActividadRespuestaRiesgoBean.java
/**********************************************************************/
/**********************************************************************/
/********************* IMPORT'S ******************************/
/**********************************************************************/
/**********************************************************************/
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++ SDK-UNA ++++++++++++++++++++++++++*/
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
import cr.ac.una.cgi.sdkuna.view.commons.CRUD;
import cr.ac.una.cgi.sdkuna.view.commons.CRUDColumn;
import cr.ac.una.cgi.sdkuna.view.commons.CRUDImpl;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++ SPRING-BOOT ++++++++++++++++++++++++++*/
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.beans.factory.annotation.Autowired;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++ CAMPOS ++++++++++++++++++++++++++*/
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Collections;
import java.util.Comparator;
import javax.annotation.PostConstruct;
import javax.faces.context.FacesContext;
import org.omnifaces.util.Ajax;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*++++++++++++ DOMAIN Y SERVICE ++++++++++++++++++++*/
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadRespuestaRiesgo;
import cr.ac.una.cgi.sigesa.ppi.mcg.service.ActividadRespuestaRiesgoService;
import cr.ac.una.cgi.sigesa.ppi.mcg.service.BitacoraARRService;
import cr.ac.una.cgi.sigesa.epf.cpr.domain.PeriodoAnual;
import cr.ac.una.cgi.sigesa.epf.cpr.domain.UnidadEjecutora;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.TipoActividadRiesgo;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.BitacoraARR;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.EstadoARR;
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** VARIABLES *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
// Variable para paso de parametros en LOV
private Map<String, Object> beanParams = new HashMap();
//variable que detemina si se modificó o no el estado
private Boolean existeCambioEstado;
//Variable que almacena la justificación de la Bitacora
private String justificacionBitacoraARR;
// Variable que almacena el estado Inicial para determinar si fue o no modificado
private EstadoARR estadoARRInicial;
//variable que detemina si es una actividad nueva o no
private Boolean actividadNueva;
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public void initDetails() {
if (!isPostBack()) {
// Si existe una entidad es una modificación
if(this.getEntity().getId() != null){
// obtenemos el estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// Inidicamos que no es una actividad nueva
this.setActividadNueva(false);
// Limpiamos la justificación
this.setJustificacionBitacoraARR("");
//Es una actividad Nueva
}else{
// Indicamos que es una actividad nueva
this.setActividadNueva(true);
}
// Indicamos que no existe un cambio de estado tanto para agregar como modificar
this.setExisteCambioEstado(false);
/*********************************************/
/********* Lista de BITACORA *****************/
/*********************************************/
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// Inicializar la lista de bitacora
this.getEntity().setListaBitacoraARR(bitacoraARRBean.setDetails(this.getEntity().getListaBitacoraARR()));
bitacoraARRBean.init();
}
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
@Override
public String update(){
String form;
// Si es una actualización
if(this.estadoARRInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
// Si son diferentes
}else{
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraARRModificado(this.getEntity(), this.justificacionBitacoraARR);
// Ordenamos la lista
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// obtenemos el nuevo estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// Limpiamos la Justificación
if(!this.justificacionBitacoraARR.isEmpty()){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
Ajax.update("formMantenimiento");
}
}else{
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
form = super.update();
return form;
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** ORDENAMIENTO *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
final Comparator<BitacoraARR> ORDENAR_FECHA = new Comparator<BitacoraARR>() {
public int compare(BitacoraARR l1, BitacoraARR l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** ORDENAMIENTO *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/********************** FUNCIONES: justificacionBitacoraARR **********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public String getJustificacionBitacoraARR() {
return justificacionBitacoraARR;
}
public void setJustificacionBitacoraARR(String justificacionBitacoraARR) {
this.justificacionBitacoraARR = justificacionBitacoraARR;
}
public Boolean isActividadNueva() {
return this.actividadNueva;
}
public void setActividadNueva(Boolean actividadNueva) {
this.actividadNueva = actividadNueva;
}
/*************************************************************************************************/
/*************************************************************************************************/
/******************** FIN FUNCIONES: justificacionBitacoraARR **********************************/
/*************************************************************************************************/
/*************************************************************************************************/
/**********************************************************************/
/**
* Función que actualiza el estado
* @author Gustavo Matamoros González
* @since 18/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioEstado(){
// Si es una actualización
if(this.estadoARRInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}else{
this.setExisteCambioEstado(true);
}
}else{
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
}
import cr.ac.una.cgi.sdkuna.view.commons.CRUD;
import cr.ac.una.cgi.sdkuna.view.commons.CRUDColumn;
import cr.ac.una.cgi.sdkuna.view.commons.CRUDImpl;
import cr.ac.una.cgi.sigesa.epf.cpr.domain.PeriodoAnual;
import cr.ac.una.cgi.sigesa.epf.cpr.domain.UnidadEjecutora;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadMejora;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.BitacoraAM;
import cr.ac.una.cgi.sigesa.ppi.mcg.service.ActividadMejoraService;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.EstadoAM;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.Comparator;
import javax.annotation.PostConstruct;
import org.springframework.context.annotation.Scope;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.omnifaces.util.Ajax;
private Boolean existeCambioEstado;
private String justificacionBitacoraAM;
private EstadoAM estadoAMInicial;
private Boolean actividadNueva;
// Odernar descendente l2 -> l1
final Comparator<BitacoraAM> ORDENAR_FECHA = new Comparator<BitacoraAM>() {
public int compare(BitacoraAM l1, BitacoraAM l2) {
return l2.getFechaHora().compareTo(l1.getFechaHora());
}
};
public void initDetails() {
if (!isPostBack()) {
if(this.getEntity().getId() != null){
this.estadoAMInicial = this.getEntity().getEstadoAM();
this.setActividadNueva(false);
this.setJustificacionBitacoraAM("");
}else{
this.setActividadNueva(true);
}
this.setExisteCambioEstado(false);
if (this.getEntity().getListaBitacoraAM() != null) {
Collections.sort(this.getEntity().getListaBitacoraAM(), ORDENAR_FECHA);
}
this.getEntity().setListaBitacoraAM(bitacoraAMBean.setDetails(this.getEntity().getListaBitacoraAM()));
bitacoraAMBean.init();
}
}
@Override
public String update(){
String form;
// Si es una actualización
if(this.estadoAMInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
// Si son diferentes
}else{
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraAMModificado(this.getEntity(), this.justificacionBitacoraAM);
// Ordenamos la lista
if (this.getEntity().getListaBitacoraAM() != null) {
Collections.sort(this.getEntity().getListaBitacoraAM(), ORDENAR_FECHA);
}
// obtenemos el nuevo estado Actual para luego compararlo
this.estadoAMInicial = this.getEntity().getEstadoAM();
// Limpiamos la Justificación
if(!this.justificacionBitacoraAM.isEmpty()){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}
Ajax.update("formMantenimiento");
}
}else{
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}
form = super.update();
return form;
}
/**
* PPI-380
* @autor: Gustavo Matamoros González
*/
public String getJustificacionBitacoraAM() {
return justificacionBitacoraAM;
}
public void setJustificacionBitacoraAM(String justificacionBitacoraAM) {
this.justificacionBitacoraAM = justificacionBitacoraAM;
}
/**
* PPI-380
* @autor: Gustavo Matamoros González
*/
public Boolean isActividadNueva() {
return this.actividadNueva;
}
public void setActividadNueva(Boolean actividadNueva) {
this.actividadNueva = actividadNueva;
}
/**********************************************************************/
/**
* Función que actualiza el estado
* @author Gustavo Matamoros González
* @since 18/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioEstado(){
// Si es una actualización
if(this.estadoAMInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}else{
this.setExisteCambioEstado(true);
}
}else{
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
}
}
Validaciones
Para hacerla las validaciones
El usuario administrador del módulo MCG puede seleccionar el estado Descartada, para lo cual debe adjuntar un oficio y digitar la justificación de manera obligatoria.
Al descartar una actividad pasa a estar inactivo el registro.
ActividadRespuestaRiesgoServiceImpl.java
Creamos una función que nos determine si el estado es descartada
/**********************************************************************/
/*********** VALIDACIÓN: Estado ARR DESCARTADA *************/
/**********************************************************************/
/**
* Metodo que determina si el EstadoARR pasado por parametro es igual a descartada
* Ver {@link ActividadRespuestaRiesgoService#esEstadoARRDescartada()) }
*
* @param estadoARR_descartada
* @return Boolean
*/
@Override
public Boolean esEstadoARRDescartada(EstadoARR estadoARR_descartada) {
if(estadoARRService.obtenerEstadoARRDescartada().equals(estadoARR_descartada)){
return true;
}
return false;
}
ActividadRespuestaRiesgoService.java
Definición
/**********************************************************************/
/*********** VALIDACIÓN: Estado ARR DESCARTADA *************/
/**********************************************************************/
/**
* Definición que determina si el EstadoARR pasado por parametro es igual a descartada
* Ver {@link ActividadRespuestaRiesgoService#esEstadoARRDescartada()) }
*
* @param estadoARR_descartada
* @return Boolean
*/
public Boolean esEstadoARRDescartada(EstadoARR estadoARR_descartada);
/******************************************/
/********** VALIDACIÓN: descartada *******/
/******************************************/
// PPI-380 / PPI-381: Al descartar una actividad pasa a estar inactivo el registro y solicitar adjunto
if(service.esEstadoARRDescartada( this.getEntity().getEstadoARR() )){
// Validar que tiene adjunto
if (adjuntoController.getDocumentoAGDs().isEmpty()) {
this.errorMessage("actividadRespuestaRiesgo_falta_adjunto_error_summary");
throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, "actividadRespuestaRiesgo_falta_adjunto_error_summary", "actividadRespuestaRiesgo_falta_adjunto_error_detail"));
}
// Desactivar registro
this.getEntity().setActivo(false);
}
Final
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
@Override
public String update(){
String form;
// Si es una actualización
if(this.estadoARRInicial !=null){
// El estado Inicial es igual al actual
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
// Si son diferentes
}else{
/******************************************/
/********** VALIDACIÓN: descartada *******/
/******************************************/
// PPI-380 / PPI-381: Al descartar una actividad pasa a estar inactivo el registro y solicitar adjunto
if(service.esEstadoARRDescartada( this.getEntity().getEstadoARR() )){
// Validar que tiene adjunto
if (adjuntoController.getDocumentoAGDs().isEmpty()) {
this.errorMessage("actividadRespuestaRiesgo_falta_adjunto_error_summary");
throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, "actividadRespuestaRiesgo_falta_adjunto_error_summary", "actividadRespuestaRiesgo_falta_adjunto_error_detail"));
}
// Desactivar registro
this.getEntity().setActivo(false);
}
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraARRModificado(this.getEntity(), this.justificacionBitacoraARR);
// Ordenamos la lista
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// obtenemos el nuevo estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// Limpiamos la Justificación
if(!this.justificacionBitacoraARR.isEmpty()){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
}
}else{
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
}
form = super.update();
return form;
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
Creación de método de calculo de porcentaje de avance
Lo primero que vamos hacer es modificar la interfa para que cuando exista un cambio de periodo llame a un metodo que realice el calculo del promedio y ejecute las tareas respectivas
MetaPoaEvaluacionSpecs.java
Lo primero que vamos hacer es crear un archivo de especificación que nos devuelva una lista lista ordenada por fecha de etapa_plan ordenada DESC, para planes operativos activos
package cr.ac.una.cgi.sigesa.ppi.ppo.specs;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.springframework.data.jpa.domain.Specification;
import cr.ac.una.cgi.sigesa.epf.cpr.domain.PeriodoAnual;
import cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadRespuestaRiesgo;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.EtapaPlan;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.MetaPoa;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.MetaPoaActividadRiesgo;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.MetaPoaEvaluacion;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.ObjetivoPOA;
import cr.ac.una.cgi.sigesa.ppi.ppo.domain.PlanOperativo;
/**
*
* @author Gustavo Matamoros González
* @version 0.0.1
* 24/04/2023
*
*/
public class MetaPoaEvaluacionSpecs {
/*************************************************************************************************/
/*************************************************************************************************/
/****** SPECIFICATION: actividadRespuestaRiesgoEqualsAndPeriodoAnualEquals ****************/
/*************************************************************************************************/
/*************************************************************************************************/
/**
SELECT
*
FROM PPI.META_POA_EVALUACION MPE
INNER JOIN PPI.ETAPA_PLAN EP ON (EP.ID_ETAPA_PLAN = MPE.ETAPA_PLAN)
INNER JOIN PPI.META_POA MP ON (MP.ID_META_POA = MPE.META_POA)
INNER JOIN OBJETIVO_POA OP ON (OP.ID_OBJETIVO_POA = MP.OBJETIVO_POA)
INNER JOIN PPI.PLAN_OPERATIVO PO ON (PO.ID_PLAN_OPERATIVO = OP.PLAN_OPERATIVO AND PO.ACTIVO = 1)
INNER JOIN PPI.META_POA_ACTIVIDAD_RIESGO MPAR ON (MPAR.META_POA = MP.ID_META_POA)
INNER JOIN PPI.ACTIVIDAD_RESPUESTA_RIESGO ARR ON (ARR.ID_ACTIVIDAD_RESPUESTA_RIESGO = MPAR.ACTIVIDAD_RESPUESTA_RIESGO)
WHERE
ARR.ID_ACTIVIDAD_RESPUESTA_RIESGO = 49
AND
EP.PERIODO_ANUAL = 202
*/
public static Specification<MetaPoaEvaluacion> actividadRespuestaRiesgoEqualsAndPeriodoAnualEquals(final ActividadRespuestaRiesgo actividadRespuestaRiesgo, final PeriodoAnual periodoAnual) {
return new Specification<MetaPoaEvaluacion>() {
@Override
public Predicate toPredicate(Root<MetaPoaEvaluacion> root, CriteriaQuery<?> cq,
CriteriaBuilder cb) {
//INNER JOIN PPI.ETAPA_PLAN EP ON (EP.ID_ETAPA_PLAN = MPE.ETAPA_PLAN)
Join<EtapaPlan, MetaPoaEvaluacion> joinEtapaPlan = root.join("etapaPlan");
//INNER JOIN PPI.META_POA MP ON (MP.ID_META_POA = MPE.META_POA)
Join<MetaPoa, MetaPoaEvaluacion> joinMetaPoa = root.join("metaPoa");
//INNER JOIN OBJETIVO_POA OP ON (OP.ID_OBJETIVO_POA = MP.OBJETIVO_POA)
Join<ObjetivoPOA, MetaPoa> joinObjetivoPOA = joinMetaPoa.join("objetivoPOA");
//INNER JOIN PPI.PLAN_OPERATIVO PO ON (PO.ID_PLAN_OPERATIVO = OP.PLAN_OPERATIVO AND PO.ACTIVO = 1)
Join<PlanOperativo, ObjetivoPOA> joinPlanOperativo = joinObjetivoPOA.join("planOperativo");
// INNER JOIN PPI.META_POA_ACTIVIDAD_RIESGO MPAR ON (MPAR.META_POA = MP.ID_META_POA)
Join<MetaPoaActividadRiesgo, MetaPoa> joinMetaPoaActividadRiesgo = joinMetaPoa.join("listaMetaPoaActividadesRiesgo");
// INNER JOIN PPI.ACTIVIDAD_RESPUESTA_RIESGO ARR ON (ARR.ID_ACTIVIDAD_RESPUESTA_RIESGO = MPAR.ACTIVIDAD_RESPUESTA_RIESGO
Join<ActividadRespuestaRiesgo, MetaPoaActividadRiesgo> joinActividadRespuestaRiesgo = joinMetaPoaActividadRiesgo.join("actividadRespuestaRiesgo");
if(actividadRespuestaRiesgo !=null && periodoAnual != null){
// Actividad Respuesta Riesgo Equals
Expression arrExp = joinActividadRespuestaRiesgo.get("id");
Expression arrLit = cb.literal(actividadRespuestaRiesgo.getId());
// Plan Operativo Activo
Expression planOperativoExp = joinPlanOperativo.get("activo");
Expression planOperativoLit = cb.literal(true);
// Periodo Anual Equals
Expression periodoAnualExp = joinEtapaPlan.get("periodoAnual");
Expression periodoAnualLit = cb.literal(periodoAnual);
// Ordenar por etapaPlan.fechaFinal descendente
Expression fechaFinal = joinEtapaPlan.get("fechaFinal");
cq.orderBy(cb.desc(fechaFinal));
return cb.and(cb.equal(planOperativoExp, planOperativoLit),cb.equal(arrExp, arrLit),cb.equal(periodoAnualExp, periodoAnualLit));
}
return null;
}
};
}
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
}
MetaPoaEvaluacionService.java
Creamos un servicio que utilice esta especificacion
/**********************************************************************/
/**
* Definicion que retorna un list<MetaPoaEvaluacion> para un planOperativo activo
* Ver {@link MetaPoaEvaluacionService#findAllByByActividadRespuestaRiesgoAndPeriodoAnual(cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadRespuestaRiesgo,cr.ac.una.cgi.sigesa.epf.cpr.domain.PeriodoAnual) }
*
* @param actividadRespuestaRiesgo
* @author: Gustavo Matamoros González
* @issue PPI-380 / PPI-381
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
/**********************************************************************/
public List<MetaPoaEvaluacion> findAllByByActividadRespuestaRiesgoAndPeriodoAnual(ActividadRespuestaRiesgo actividadRespuestaRiesgo, PeriodoAnual periodoAnual);
MetaPoaEvaluacionServiceImpl.java
Creamos el método
/**********************************************************************/
/**
* Método que retorna un list<MetaPoaEvaluacion> para un planOperativo activo
* Ver {@link MetaPoaEvaluacionService#findAllByByActividadRespuestaRiesgoAndPeriodoAnual(cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadRespuestaRiesgo,cr.ac.una.cgi.sigesa.epf.cpr.domain.PeriodoAnual) }
*
* @param actividadRespuestaRiesgo
* @author: Gustavo Matamoros González
* @issue PPI-380 / PPI-381
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
/**********************************************************************/
@Override
public List<MetaPoaEvaluacion> findAllByByActividadRespuestaRiesgoAndPeriodoAnual(ActividadRespuestaRiesgo actividadRespuestaRiesgo, PeriodoAnual periodoAnual) {
// Definimos una variable de tipo especificacion MetaPoaEvaluacion
Specification<MetaPoaEvaluacion> specFinal;
// Obtenemos la especificación de actividadRespuestaRiesgoEquals
Specification specActividadRespuestaRiesgoEqualsAndPeriodoAnualEquals = MetaPoaEvaluacionSpecs.actividadRespuestaRiesgoEqualsAndPeriodoAnualEquals(actividadRespuestaRiesgo, periodoAnual);
// Creamos la especificación final
specFinal = Specification.where(specActividadRespuestaRiesgoEqualsAndPeriodoAnualEquals);
return repository.findAll(specFinal);
}
actividadRespuestaRiesgoEditForm.xhtml
Periodo Inicial
En periodo Inicial modificamos el ajax del autocomplete
Creamos una función que obtenga una lista de MetaPoaEvaluacion segun ARR y PeriodoAnual
/****************************************************************************************/
/****************************************************************************************/
/***************************** BITACORA **************************************/
/****************************************************************************************/
/****************************************************************************************/
/**
* Metodo que obtiene una List<MetaPoaEvaluacion> según una Actividad de Respuesta al Riesgo y un periodo
*
* @author Gustavo Matamoros González
* @since 27/04/2023
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
@Override
public List<MetaPoaEvaluacion> obtenerMetaPoaEvaluacionByActividadRespuestaRiesgoAndPeriodoAnual(ActividadRespuestaRiesgo actividadRespuestaRiesgo, PeriodoAnual periodoAnual) {
return metaPoaEvaluacionService.findAllByByActividadRespuestaRiesgoAndPeriodoAnual(actividadRespuestaRiesgo, periodoAnual);
}
y seguido creammos una función que calcule el porcentaje de ejecución de la actividad
/**
* Metodo que calcula el porcentaje de ejecución de una actividad
*
* @author Gustavo Matamoros González
* @since 27/04/2023
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
@Override
public BigDecimal calculaPorcentajeEjecucionARR(ActividadRespuestaRiesgo actividadRespuestaRiesgo){
// Obtener el año inicial y final de la entidad
Integer annoInicial = actividadRespuestaRiesgo.getPeriodoAnualInicial().getAno();
Integer annoFinal = actividadRespuestaRiesgo.getPeriodoAnualFinal().getAno();
// Variable para obtener la cantidad de periodos seleccionados
Integer cantidadPeriodos = 0;
// Variable para obtener la totalidad de ejecucion de todos los periodos
BigDecimal totalEjecucionPeriodos = BigDecimal.ZERO;
// Creamos una lista temporal limpia
List<MetaPoaEvaluacion> listaMetaPoaEvaluacionPorPeriodo = new ArrayList<>();
//NOTA: Obtener el año del periodo inicial de las evaluaciones esto por que inician a partir del año 2023
PeriodoAnual periodoInicialEvaluaciones = periodoAnualService.findOne(Long.parseLong(parametroService.findOneByLlave("param_ppi_mcg_periodoInicialEvaluacionesActividadesARRyAM").getValor()));
// Obtenemos el año del periodo
Integer annoInicialEvaluaciones = periodoInicialEvaluaciones.getAno();
// Determinar si annoInicial es menor al inicio de la evaluaciones
if (annoInicial < annoInicialEvaluaciones){
annoInicial = annoInicialEvaluaciones;
}
// Recorrer los periodos anuales para obtener la última evaluación de cada periodo
for (int i = annoInicial; i <= annoFinal; i++) {
// limpiamos la lista
listaMetaPoaEvaluacionPorPeriodo.clear();
// Obtenemos la lista de MetaPoaEvaluacion por periodo que viene ordenada por fecha descendente
listaMetaPoaEvaluacionPorPeriodo = obtenerMetaPoaEvaluacionByActividadRespuestaRiesgoAndPeriodoAnual(actividadRespuestaRiesgo,periodoAnualService.findPeriodoAnualByAnno(i));
// Si la lista no esta vacia para el año existen evaluaciones
if(!listaMetaPoaEvaluacionPorPeriodo.isEmpty()){
// Se convierte a String
String strPorcentajeEvaluacion = String.valueOf(listaMetaPoaEvaluacionPorPeriodo.get(0).getEjecucion());
// Se convierte a BigDecimal con 2 digitos
BigDecimal montoEjecucion = new BigDecimal(strPorcentajeEvaluacion).setScale(2, BigDecimal.ROUND_HALF_EVEN);
// Obtenemos el primer elemento o la última evaluacion y se lo sumamos al total
totalEjecucionPeriodos = totalEjecucionPeriodos.add(montoEjecucion);
}
// aumentamos la cantidad de periodos
cantidadPeriodos++;
}
// Si existe al menos un periodo
if(cantidadPeriodos > 0){
BigDecimal cantidadPeriodosBD = new BigDecimal(cantidadPeriodos);
// Verificar la división de cero
if(totalEjecucionPeriodos.compareTo(BigDecimal.ZERO) == 0){
return totalEjecucionPeriodos;
// Si existen valores
}else{
// eliminar decimales
return totalEjecucionPeriodos.divide(cantidadPeriodosBD,2,RoundingMode.CEILING);
}
}
return totalEjecucionPeriodos;
}
Ahora creamos las funciones para poder obtener los diferentes estados
/****************************************************************************************/
/****************************************************************************************/
/***************************** ESTADOS ARR **************************************/
/****************************************************************************************/
/****************************************************************************************/
/**
* Metodo que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
@Override
public EstadoARR obtenerEstadoARRSinIniciar() {
return estadoARRService.obtenerEstadoARRSinIniciar();
}
/**
* Metodo que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
@Override
public EstadoARR obtenerEstadoARREnProceso() {
return estadoARRService.obtenerEstadoARREnProceso();
}
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
@Override
public EstadoARR obtenerEstadoARRDescartada() {
return estadoARRService.obtenerEstadoARRDescartada();
}
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
@Override
public EstadoARR obtenerEstadoARRImplementada() {
return estadoARRService.obtenerEstadoARRImplementada();
}
/**
* Definición que obtiene una List<MetaPoaEvaluacion> según una Actividad de Respuesta al Riesgo y un periodo
*
* @author Gustavo Matamoros González
* @since 27/04/2023
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
public List<MetaPoaEvaluacion> obtenerMetaPoaEvaluacionByActividadRespuestaRiesgoAndPeriodoAnual(ActividadRespuestaRiesgo actividadRespuestaRiesgo, PeriodoAnual periodoAnual);
/**
* Metodo que calcula el porcentaje de ejecución de una actividad
*
* @author Gustavo Matamoros González
* @since 27/04/2023
* @param actividadRespuestaRiesgo
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
public BigDecimal calculaPorcentajeEjecucionARR(ActividadRespuestaRiesgo actividadRespuestaRiesgo);
/**
* Metodo que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
public EstadoARR obtenerEstadoARRSinIniciar();
/**
* Metodo que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
public EstadoARR obtenerEstadoARREnProceso();
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
public EstadoARR obtenerEstadoARRDescartada();
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoARR
*/
public EstadoARR obtenerEstadoARRImplementada();
//variable que detemina si se debe habilitar o no la barra de progreso de porcentaje de Ejecucion
private Boolean habilitarPorcentajeEjecucion;
// variable que almacena el porcentaje de ejecución de la actividad
private BigDecimal porcentajeEjecucion;
// Variable que almacena el nombre de la clase que se debe asignar al progressBar
private String styleProgressBar;
Quedando así
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** VARIABLES *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
// Variable para paso de parametros en LOV
private Map<String, Object> beanParams = new HashMap();
//variable que detemina si se modificó o no el estado
private Boolean existeCambioEstado;
//Variable que almacena la justificación de la Bitacora
private String justificacionBitacoraARR;
// Variable que almacena el estado Inicial para determinar si fue o no modificado
private EstadoARR estadoARRInicial;
//variable que detemina si es una actividad nueva o no
private Boolean actividadNueva;
//variable que detemina si se debe habilitar o no el campo de Estado
private Boolean deshabilitarEstadoARR;
//variable que detemina si se debe habilitar o no la barra de progreso de porcentaje de Ejecucion
private Boolean habilitarPorcentajeEjecucion;
// variable que almacena el porcentaje de ejecución de la actividad
private BigDecimal porcentajeEjecucion;
// Variable que almacena el nombre de la clase que se debe asignar al progressBar
private String styleProgressBar;
Modificamos la funcion initdetails
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public void initDetails() {
if (!isPostBack()) {
// Si existe una entidad es una modificación
if(this.getEntity().getId() != null){
// obtenemos el estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// Inidicamos que no es una actividad nueva
this.setActividadNueva(false);
// Limpiamos la justificación
this.setJustificacionBitacoraARR("");
// Habilitar la selección del estado
this.setDeshabilitarEstadoARR(false);
// habilitar porcentaje ejecucion
this.setHabilitarPorcentajeEjecucion(true);
// falta obtener el valor inicial
BigDecimal porcentaje = service.calculaPorcentajeEjecucionARR(this.getEntity());
this.setPorcentajeEjecucion(porcentaje);
this.determinarColorProgressBar(porcentaje);
//Es una actividad Nueva
}else{
// Indicamos que es una actividad nueva
this.setActividadNueva(true);
// Habilitar la selección del estado
this.setDeshabilitarEstadoARR(false);
// Deshabilitar porcentaje ejecucion
this.setHabilitarPorcentajeEjecucion(false);
}
// Indicamos que no existe un cambio de estado tanto para agregar como modificar
this.setExisteCambioEstado(false);
}
/*********************************************/
/********* Lista de BITACORA *****************/
/*********************************************/
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// Inicializar la lista de bitacora
this.getEntity().setListaBitacoraARR(bitacoraARRBean.setDetails(this.getEntity().getListaBitacoraARR()));
bitacoraARRBean.init();
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN INITDETAILS *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
La funcion update
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
@Override
public String update(){
String form;
// Si es una actualización
if(this.estadoARRInicial !=null){
// El estado Inicial es igual al actual
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoARR(false);
// Si son diferentes
}else{
/******************************************/
/********** VALIDACIÓN: descartada *******/
/******************************************/
// PPI-380 / PPI-381: Al descartar una actividad pasa a estar inactivo el registro y solicitar adjunto
if(service.esEstadoARRDescartada( this.getEntity().getEstadoARR() )){
// Validar que tiene adjunto
if (adjuntoController.getDocumentoAGDs().isEmpty()) {
this.errorMessage("actividadRespuestaRiesgo_falta_adjunto_error_summary","actividadRespuestaRiesgo_falta_adjunto_error_detail");
throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("actividadRespuestaRiesgo_falta_adjunto_error"), getI18n("actividadRespuestaRiesgo_falta_adjunto_error")));
}
// Desactivar registro
this.getEntity().setActivo(false);
}
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraARRModificado(this.getEntity(), this.justificacionBitacoraARR);
// Ordenamos la lista
if (this.getEntity().getListaBitacoraARR() != null) {
Collections.sort(this.getEntity().getListaBitacoraARR(), ORDENAR_FECHA);
}
// obtenemos el nuevo estado Actual para luego compararlo
this.estadoARRInicial = this.getEntity().getEstadoARR();
// Limpiamos la Justificación
if(!this.justificacionBitacoraARR.isEmpty()){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoARR(false);
}
}
}else{
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoARR(false);
}
form = super.update();
return form;
}
/*************************************************************************************************/
/*************************************************************************************************/
/****************************** FIN FUNCIÓN UPDATE *********************************************/
/*************************************************************************************************/
/*************************************************************************************************/
Creamos las funciones de procentaje de ejecuación
/*************************************************************************************************/
/*************************************************************************************************/
/********************** FUNCIONES: Porcentaje Ejecucion *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public Boolean isHabilitarPorcentajeEjecucion() {
return habilitarPorcentajeEjecucion;
}
public void setHabilitarPorcentajeEjecucion(Boolean habilitarPorcentajeEjecucion) {
this.habilitarPorcentajeEjecucion = habilitarPorcentajeEjecucion;
}
public BigDecimal getPorcentajeEjecucion() {
return porcentajeEjecucion;
}
public void setPorcentajeEjecucion(BigDecimal porcentajeEjecucion) {
this.porcentajeEjecucion = porcentajeEjecucion;
}
public String getStyleProgressBar() {
return styleProgressBar;
}
public void setStyleProgressBar(String styleProgressBar) {
this.styleProgressBar = styleProgressBar;
}
/*************************************************************************************************/
/*************************************************************************************************/
/********************** FIN FUNCIONES: Porcentaje Ejecucion *********************************/
/*************************************************************************************************/
/*************************************************************************************************/
Agregamos las funciones de deshabilitar estadoARR
/*************************************************************************************************/
/*************************************************************************************************/
/********************** FUNCIONES: Estado ARR ************************************/
/*************************************************************************************************/
/*************************************************************************************************/
public Page<EstadoARR> completeEstadoARR(String query, Pageable pageable) {
return service.autoCompleteEstadoARR(query, pageable);
}
/* Clear: Estado ARR */
public void handleClearEstadoARR() {
this.getEntity().setEstadoARR(null);
}
public Boolean isDeshabilitarEstadoARR() {
return this.deshabilitarEstadoARR;
}
public void setDeshabilitarEstadoARR(Boolean deshabilitarEstadoARR) {
this.deshabilitarEstadoARR = deshabilitarEstadoARR;
}
/*************************************************************************************************/
/*************************************************************************************************/
/********************** FIN FUNCIONES: Estado ARR ************************************/
/*************************************************************************************************/
/*************************************************************************************************/
Agregamos la función que actulizar el cambio de periodo
/**********************************************************************/
/**
* Función que verifica un cambio de periodo
* @author Gustavo Matamoros González
* @since 26/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioPeriodo(){
if(!this.isActividadNueva()){
Integer annofechaInicial = this.getEntity().getAnnoPeriodoAnualInicial();
Integer annofechaFinal = this.getEntity().getAnnoPeriodoAnualFinal();
if((annofechaFinal != null) && (annofechaInicial != null)){
// VALIDACIÓN: AñoInicial > AñoFinal
if (annofechaFinal.compareTo(annofechaInicial) < 0) {
//this.errorMessage("actividadRespuestaRiesgo_falta_adjunto_error_summary","actividadRespuestaRiesgo_falta_adjunto_error_detail");
//throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("actividadRespuestaRiesgo_falta_adjunto_error"), getI18n("actividadRespuestaRiesgo_falta_adjunto_error")));
//throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("AAA"), getI18n("actividadRespuestaRiesgo_falta_adjunto_error")));
}else{
//Obtenemos el procentaje de ejecucion
BigDecimal porcentaje = service.calculaPorcentajeEjecucionARR(this.getEntity());
BigDecimal indicador = new BigDecimal(100);
// Si porcentaje es menor a 100 es en proceso
if(porcentaje.compareTo(indicador) < 0){
if(this.estadoARRInicial !=null){
// El estado actual es igual en proceso
if(this.getEntity().getEstadoARR().equals(service.obtenerEstadoARREnProceso())){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoARR(false);
this.setPorcentajeEjecucion(porcentaje);
// Si el estado inicial es diferente a en proceso
}else{
this.getEntity().setEstadoARR(service.obtenerEstadoARREnProceso());
this.setExisteCambioEstado(true);
this.setJustificacionBitacoraARR("");
this.setDeshabilitarEstadoARR(true);
this.setPorcentajeEjecucion(porcentaje);
}
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setExisteCambioEstado(false);
this.setJustificacionBitacoraARR("");
this.setDeshabilitarEstadoARR(false);
}
}
this.determinarColorProgressBar(porcentaje);
// Si porcentaje es igual a 100 es implementada
}else if(porcentaje.compareTo(indicador) == 0){
if(this.estadoARRInicial !=null){
// El estado Inicial es igual al actual
if(this.getEntity().getEstadoARR().equals(service.obtenerEstadoARRImplementada())){
this.setJustificacionBitacoraARR("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoARR(false);
this.setPorcentajeEjecucion(porcentaje);
// Si el estado inicial es diferente a implementada
}else{
this.getEntity().setEstadoARR(service.obtenerEstadoARRImplementada());
this.setExisteCambioEstado(true);
this.setJustificacionBitacoraARR("");
this.setDeshabilitarEstadoARR(true);
this.setPorcentajeEjecucion(porcentaje);
}
if(this.getEntity().getEstadoARR().equals(this.estadoARRInicial)){
this.setExisteCambioEstado(false);
this.setJustificacionBitacoraARR("");
this.setDeshabilitarEstadoARR(false);
}
}
this.determinarColorProgressBar(porcentaje);
}
}
}
}
}
Creamos la función que se encarga de establecer la clase de la barra de progreso
/*************************************************************************************************/
/*************************************************************************************************/
/******************** DISEÑO **********************************/
/*************************************************************************************************/
/*************************************************************************************************/
public void determinarColorProgressBar(BigDecimal porcentaje){
BigDecimal indicador1 = new BigDecimal(0);
BigDecimal indicador2 = new BigDecimal(50);
BigDecimal indicador3 = new BigDecimal(100);
if( (porcentaje.compareTo(indicador1)>= 0) && (porcentaje.compareTo(indicador2)<= 0)){
this.setStyleProgressBar("colorBarraMenor50");
}else if((porcentaje.compareTo(indicador2)>= 0) && (porcentaje.compareTo(indicador3)< 0)){
this.setStyleProgressBar("colorBarraMenor100");
}else if (porcentaje.compareTo(indicador3)== 0){
this.setStyleProgressBar("colorBarra100");
}
}
Calculo para Actividad Mejora
Ahora vamos a crear la especificación para obtener la META_POA_EVALUACION para una actividad de mejora
SQL
SELECT
*
FROM PPI.META_POA_EVALUACION MPE
INNER JOIN PPI.ETAPA_PLAN EP ON (EP.ID_ETAPA_PLAN = MPE.ETAPA_PLAN)
INNER JOIN PPI.META_POA MP ON (MP.ID_META_POA = MPE.META_POA)
INNER JOIN OBJETIVO_POA OP ON (OP.ID_OBJETIVO_POA = MP.OBJETIVO_POA)
INNER JOIN PPI.PLAN_OPERATIVO PO ON (PO.ID_PLAN_OPERATIVO = OP.PLAN_OPERATIVO AND PO.ACTIVO = 1)
INNER JOIN PPI.META_POA_ACTIVIDAD_MEJORA MPAM ON (MPAM.META_POA = MP.ID_META_POA)
INNER JOIN PPI.ACTIVIDAD_MEJORA AM ON (AM.ID_ACTIVIDAD_MEJORA = MPAM.ACTIVIDAD_MEJORA)
WHERE
AM.ID_ACTIVIDAD_MEJORA = 15
AND
EP.PERIODO_ANUAL = 202
Creamos una función que obtenga una lista de MetaPoaEvaluacion segun AM y PeriodoAnual
/**
* Metodo que obtiene una List<MetaPoaEvaluacion> según una Actividad de Mejora y un periodo
*
* @author Gustavo Matamoros González
* @since 28/04/2023
* @param actividadMejora
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
@Override
public List<MetaPoaEvaluacion> obtenerMetaPoaEvaluacionByActividadMejoraAndPeriodoAnual(ActividadMejora actividadMejora, PeriodoAnual periodoAnual) {
return metaPoaEvaluacionService.findAllByByActividadMejoraAndPeriodoAnual(actividadMejora, periodoAnual);
}
y seguido creammos una función que calcule el porcentaje de ejecución de la actividad
/**
* Metodo que calcula el porcentaje de ejecución de una actividad
*
* @author Gustavo Matamoros González
* @since 28/04/2023
* @param actividadMejora
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
@Override
public BigDecimal calculaPorcentajeEjecucionAM(ActividadMejora actividadMejora){
// Obtener el año inicial y final de la entidad
Integer annoInicial = actividadMejora.getPeriodoAnualInicial().getAno();
Integer annoFinal = actividadMejora.getPeriodoAnualFinal().getAno();
// Variable para obtener la cantidad de periodos seleccionados
Integer cantidadPeriodos = 0;
// Variable para obtener la totalidad de ejecucion de todos los periodos
BigDecimal totalEjecucionPeriodos = BigDecimal.ZERO;
// Creamos una lista temporal limpia
List<MetaPoaEvaluacion> listaMetaPoaEvaluacionPorPeriodo = new ArrayList<>();
//NOTA: Obtener el año del periodo inicial de las evaluaciones esto por que inician a partir del año 2023
PeriodoAnual periodoInicialEvaluaciones = periodoAnualService.findOne(Long.parseLong(parametroService.findOneByLlave("param_ppi_mcg_periodoInicialEvaluacionesActividadesARRyAM").getValor()));
// Obtenemos el año del periodo
Integer annoInicialEvaluaciones = periodoInicialEvaluaciones.getAno();
// Determinar si annoInicial es menor al inicio de la evaluaciones
if (annoInicial < annoInicialEvaluaciones){
annoInicial = annoInicialEvaluaciones;
}
// Recorrer los periodos anuales para obtener la última evaluación de cada periodo
for (int i = annoInicial; i <= annoFinal; i++) {
// limpiamos la lista
listaMetaPoaEvaluacionPorPeriodo.clear();
// Obtenemos la lista de MetaPoaEvaluacion por periodo que viene ordenada por fecha descendente
listaMetaPoaEvaluacionPorPeriodo = obtenerMetaPoaEvaluacionByActividadMejoraAndPeriodoAnual(actividadMejora,periodoAnualService.findPeriodoAnualByAnno(i));
// Si la lista no esta vacia para el año existen evaluaciones
if(!listaMetaPoaEvaluacionPorPeriodo.isEmpty()){
// Se convierte a String
String strPorcentajeEvaluacion = String.valueOf(listaMetaPoaEvaluacionPorPeriodo.get(0).getEjecucion());
// Se convierte a BigDecimal con 2 digitos
BigDecimal montoEjecucion = new BigDecimal(strPorcentajeEvaluacion).setScale(2, BigDecimal.ROUND_HALF_EVEN);
// Obtenemos el primer elemento o la última evaluacion y se lo sumamos al total
totalEjecucionPeriodos = totalEjecucionPeriodos.add(montoEjecucion);
}
// aumentamos la cantidad de periodos
cantidadPeriodos++;
}
// Si existe al menos un periodo
if(cantidadPeriodos > 0){
BigDecimal cantidadPeriodosBD = new BigDecimal(cantidadPeriodos);
// Verificar la división de cero
if(totalEjecucionPeriodos.compareTo(BigDecimal.ZERO) == 0){
return totalEjecucionPeriodos;
// Si existen valores
}else{
// eliminar decimales
return totalEjecucionPeriodos.divide(cantidadPeriodosBD,2,RoundingMode.CEILING);
}
}
return totalEjecucionPeriodos;
}
Ahora creamos las funciones para poder obtener los diferentes estados
/**
* Metodo que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 28/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMSinIniciar() {
return estadoAMService.obtenerEstadoAMSinIniciar();
}
/**
* Metodo que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMEnProceso() {
return estadoAMService.obtenerEstadoAMEnProceso();
}
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMDescartada() {
return estadoAMService.obtenerEstadoAMDescartada();
}
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
@Override
public EstadoAM obtenerEstadoAMImplementada() {
return estadoAMService.obtenerEstadoAMImplementada();
}
/**
* Definición que obtiene una List<MetaPoaEvaluacion> según una Actividad de Mejora y un periodo
*
* @author Gustavo Matamoros González
* @since 28/04/2023
* @param actividadMejora
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
public List<MetaPoaEvaluacion> obtenerMetaPoaEvaluacionByActividadMejoraAndPeriodoAnual(ActividadMejora actividadMejora, PeriodoAnual periodoAnual);
/**
* Metodo que calcula el porcentaje de ejecución de una actividad
*
* @author Gustavo Matamoros González
* @since 27/04/2023
* @param actividadMejora
* @param periodoAnual
* @return List<MetaPoaEvaluacion>
*/
public BigDecimal calculaPorcentajeEjecucionARR(ActividadMejora actividadMejora);
/**
* Metodo que obtiene el estado sinIniciar.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMSinIniciar();
/**
* Metodo que obtiene el estado enProceso.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMEnProceso();
/**
* Metodo que obtiene el estado descartada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMDescartada();
/**
* Metodo que obtiene el estado implementada.
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return EstadoAM
*/
public EstadoAM obtenerEstadoAMImplementada();
@Override
public String update(){
String form;
// Si es una actualización
if(this.estadoAMInicial !=null){
// Preguntamos si es igual al estado inicial reiniciamos la justificación
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoAM(false);
// Si son diferentes
}else{
/******************************************/
/********** VALIDACIÓN: descartada *******/
/******************************************/
// PPI-380 / PPI-381: Al descartar una actividad pasa a estar inactivo el registro.
if(service.esEstadoAMDescartada( this.getEntity().getEstadoAM() )){
if (adjuntoController.getDocumentoAGDs().isEmpty()) {
this.errorMessage("actividadMejora_falta_adjunto_error_summary","actividadMejora_falta_adjunto_error_detail");
throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("actividadMejora_falta_adjunto_error"), getI18n("actividadMejora_falta_adjunto_error")));
}
this.getEntity().setActivo(false);
}
// Mandamos a crear una Bitacora y agregarla a la lista
service.creaBitacoraAMModificado(this.getEntity(), this.justificacionBitacoraAM);
// Ordenamos la lista
if (this.getEntity().getListaBitacoraAM() != null) {
Collections.sort(this.getEntity().getListaBitacoraAM(), ORDENAR_FECHA);
}
// obtenemos el nuevo estado Actual para luego compararlo
this.estadoAMInicial = this.getEntity().getEstadoAM();
// Limpiamos la Justificación
if(!this.justificacionBitacoraAM.isEmpty()){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoAM(false);
}
}
}else{
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoAM(false);
}
form = super.update();
return form;
}
Creamos las funciones de procentaje de ejecuación
public Boolean isHabilitarPorcentajeEjecucion() {
return habilitarPorcentajeEjecucion;
}
public void setHabilitarPorcentajeEjecucion(Boolean habilitarPorcentajeEjecucion) {
this.habilitarPorcentajeEjecucion = habilitarPorcentajeEjecucion;
}
public BigDecimal getPorcentajeEjecucion() {
return porcentajeEjecucion;
}
public void setPorcentajeEjecucion(BigDecimal porcentajeEjecucion) {
this.porcentajeEjecucion = porcentajeEjecucion;
}
public String getStyleProgressBar() {
return styleProgressBar;
}
public void setStyleProgressBar(String styleProgressBar) {
this.styleProgressBar = styleProgressBar;
}
Agregamos las funciones de deshabilitar estadoARR
public Boolean isDeshabilitarEstadoAM() {
return this.deshabilitarEstadoAM;
}
public void setDeshabilitarEstadoAM(Boolean deshabilitarEstadoAM) {
this.deshabilitarEstadoAM = deshabilitarEstadoAM;
}
Agregamos la función que actulizar el cambio de periodo
/**********************************************************************/
/**
* Función que verifica un cambio de periodo
* @author Gustavo Matamoros González
* @since 28/04/2023
* @issue PPI-380
* @return void
*/
/**********************************************************************/
public void actualizaExisteCambioPeriodo(){
if(!this.isActividadNueva()){
Integer annofechaInicial = this.getEntity().getAnnoPeriodoAnualInicial();
Integer annofechaFinal = this.getEntity().getAnnoPeriodoAnualFinal();
if((annofechaFinal != null) && (annofechaInicial != null)){
// VALIDACIÓN: AñoInicial > AñoFinal
if (annofechaFinal.compareTo(annofechaInicial) < 0) {
//this.errorMessage("actividadRespuestaRiesgo_falta_adjunto_error_summary","actividadRespuestaRiesgo_falta_adjunto_error_detail");
//throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("actividadRespuestaRiesgo_falta_adjunto_error"), getI18n("actividadRespuestaRiesgo_falta_adjunto_error")));
//throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, getI18n("AAA"), getI18n("actividadRespuestaRiesgo_falta_adjunto_error")));
}else{
//Obtenemos el procentaje de ejecucion
BigDecimal porcentaje = service.calculaPorcentajeEjecucionAM(this.getEntity());
BigDecimal indicador = new BigDecimal(100);
// Si porcentaje es menor a 100 es en proceso
if(porcentaje.compareTo(indicador) < 0){
if(this.estadoAMInicial !=null){
// El estado actual es igual en proceso
if(this.getEntity().getEstadoAM().equals(service.obtenerEstadoAMEnProceso())){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoAM(false);
this.setPorcentajeEjecucion(porcentaje);
// Si el estado inicial es diferente a en proceso
}else{
this.getEntity().setEstadoAM(service.obtenerEstadoAMEnProceso());
this.setExisteCambioEstado(true);
this.setJustificacionBitacoraAM("");
this.setDeshabilitarEstadoAM(true);
this.setPorcentajeEjecucion(porcentaje);
}
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setExisteCambioEstado(false);
this.setJustificacionBitacoraAM("");
this.setDeshabilitarEstadoAM(false);
}
}
this.determinarColorProgressBar(porcentaje);
// Si porcentaje es igual a 100 es implementada
}else if(porcentaje.compareTo(indicador) == 0){
if(this.estadoAMInicial !=null){
// El estado Inicial es igual al actual
if(this.getEntity().getEstadoAM().equals(service.obtenerEstadoAMImplementada())){
this.setJustificacionBitacoraAM("");
this.setExisteCambioEstado(false);
this.setDeshabilitarEstadoAM(false);
this.setPorcentajeEjecucion(porcentaje);
// Si el estado inicial es diferente a implementada
}else{
this.getEntity().setEstadoAM(service.obtenerEstadoAMImplementada());
this.setExisteCambioEstado(true);
this.setJustificacionBitacoraAM("");
this.setDeshabilitarEstadoAM(true);
this.setPorcentajeEjecucion(porcentaje);
}
if(this.getEntity().getEstadoAM().equals(this.estadoAMInicial)){
this.setExisteCambioEstado(false);
this.setJustificacionBitacoraAM("");
this.setDeshabilitarEstadoAM(false);
}
}
this.determinarColorProgressBar(porcentaje);
}
}
}
}
}
Creamos la función que se encarga de establecer la clase de la barra de progreso
public void determinarColorProgressBar(BigDecimal porcentaje){
BigDecimal indicador1 = new BigDecimal(0);
BigDecimal indicador2 = new BigDecimal(50);
BigDecimal indicador3 = new BigDecimal(100);
if( (porcentaje.compareTo(indicador1)>= 0) && (porcentaje.compareTo(indicador2)<= 0)){
this.setStyleProgressBar("colorBarraMenor50");
}else if((porcentaje.compareTo(indicador2)>= 0) && (porcentaje.compareTo(indicador3)< 0)){
this.setStyleProgressBar("colorBarraMenor100");
}else if (porcentaje.compareTo(indicador3)== 0){
this.setStyleProgressBar("colorBarra100");
}
}
ActividadMejora.java
Ahora para que sirva que sirva la función de calculo de cambio de perido dentro del domain deben existir las funciones de obtención del año del periodo las vamos a crear
/**********************************************************************/
/**
* Metodo que retorna un list<MetaPoaActividadRiesgo> para una actividad de Respuesta al Riesgo
* Ver {@link MetaPoaActividadRiesgoService#findAllByMetaPoa(cr.ac.una.cgi.sigesa.ppi.mcg.domain.ActividadRespuestaRiesgo) }
*
* @author: Gustavo Matamoros González
* @issue PPI-380 / PPI-381
* @param actividadRespuetasRiesgo
* @return List<MetaPoaEvaluacion>
*/
/**********************************************************************/
public List<MetaPoaActividadRiesgo> findAllByActividadRespuestaRiesgo(ActividadRespuestaRiesgo actividadRespuetasRiesgo){
return repository.findAllByActividadRespuestaRiesgo(actividadRespuetasRiesgo);
}
ActividadRespuestaRiesgoService.java
Definimos un servicio que va a actualizar las ARR segun una EvaluacionOperativa
/**
* Metodo que actualiza las Actividades de Respuesta al Riesgo según una evaluación operativa
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return void
*/
public void actualizarActividadesRespuestaRiesgoByEvaluacionOperativa(EvaluacionOperativa evaluacionOperativa);
/**
* Definición que actualiza las Actividades de Respuesta al Riesgo según una evaluación operativa
*
* @author Gustavo Matamoros González
* @since 26/04/2023
* @return void
*/
public void actualizarActividadesRespuestaRiesgoByEvaluacionOperativa(EvaluacionOperativa evaluacionOperativa){
// Obtenemos el plan operativo
PlanOperativo planOperativo = evaluacionOperativa.getPlanOperativo();
// Creamos una lista para almacenar las ARR
List<ActividadRespuestaRiesgo> listaActividadRespuestaRiesgo = new ArrayList<>();
// Obtenemos las ARR por plan operativo
listaActividadRespuestaRiesgo = this.findAllActividadRespuestaRiesgoByPlanOperativo(planOperativo);
// Si la lista no se encuetra vacia
if(!listaActividadRespuestaRiesgo.isEmpty()){
// Recorremos la lista
for(ActividadRespuestaRiesgo actividadRespuestaRiesgo : listaActividadRespuestaRiesgo){
// **********************************************
// PROCESO: ACTUALIZACIÓN DE ESTADO
// **********************************************
BigDecimal porcentaje = BigDecimal.ZERO;
// Obtenemos el porcentaje de ejecución
porcentaje = this.calculaPorcentajeEjecucionARR(actividadRespuestaRiesgo);
// Indicador de condición de cambio de estado
BigDecimal indicador = new BigDecimal(100);
// Obtenemos el estado inicial de la actividad para determinar si existe o no cambio de estado
EstadoARR estadoInicial = actividadRespuestaRiesgo.getEstadoARR();
// Bandera que determina si existe o no cambio de estado
Boolean existeCambioEstado = false;
// Si porcentaje < 100 resultado: "En Proceso"
if(porcentaje.compareTo(indicador) < 0){
if(!estadoInicial.equals(this.obtenerEstadoARREnProceso())){
actividadRespuestaRiesgo.setEstadoARR(this.obtenerEstadoARREnProceso());
existeCambioEstado = true;
}else{
existeCambioEstado = false;
}
// Si porcentaje == 100 resultado: "Implementada"
}else if(porcentaje.compareTo(indicador) == 0){
if(!estadoInicial.equals(this.obtenerEstadoARRImplementada())){
actividadRespuestaRiesgo.setEstadoARR(this.obtenerEstadoARRImplementada());
existeCambioEstado = true;
}else{
existeCambioEstado = false;
}
}
// **********************************************
// PROCESO: ACTUALIZACIÓN DE BITACORA
// **********************************************
// Si existe cambio de estado guardamos
if(existeCambioEstado){
// Guardamos el registro
this.save(actividadRespuestaRiesgo);
// Creamos una lista de MetaPoaEvaluacion limpia
List<MetaPoaEvaluacion> listaMetaPoaEvaluacionPorPeriodo = new ArrayList<>();
// Obtenemos la lista de MetaPoaEvaluacion por periodo que viene ordenada por fecha descendente
listaMetaPoaEvaluacionPorPeriodo = obtenerMetaPoaEvaluacionByActividadRespuestaRiesgoAndPeriodoAnual(actividadRespuestaRiesgo,planOperativo.getPeriodoAnual());
// Si la lista no esta vacia para el año es decir "existen evaluaciones"
if(!listaMetaPoaEvaluacionPorPeriodo.isEmpty()){
// Se obtiene la justificación de la evaluación
String justificacionEvaluacion = String.valueOf(listaMetaPoaEvaluacionPorPeriodo.get(0).getJustificacion());
// Se guarda el registro en bitacora
this.creaBitacoraARRModificado(actividadRespuestaRiesgo,justificacionEvaluacion);
}
}
}
}
}
Definimos un servicio que va a actualizar las AM segun una EvaluacionOperativa
/**
* Definición que actualiza las Actividades de mejora según una evaluación operativa
*
* @author Gustavo Matamoros González
* @since 02/05/2023
* @return void
*/
public void actualizarActividadesMejoraByEvaluacionOperativa(EvaluacionOperativa evaluacionOperativa);
/**
* Método que actualiza las Actividades de Mejora según una evaluación operativa
*
* @author Gustavo Matamoros González
* @since 02/05/2023
* @return void
*/
public void actualizarActividadesMejoraByEvaluacionOperativa(EvaluacionOperativa evaluacionOperativa){
// Obtenemos el plan operativo
PlanOperativo planOperativo = evaluacionOperativa.getPlanOperativo();
// Creamos una lista para almacenar las ARR
List<ActividadMejora> listaActividadMejora = new ArrayList<>();
// Obtenemos las ARR por plan operativo
listaActividadMejora = this.findAllActividadMejoraByPlanOperativo(planOperativo);
// Si la lista no se encuetra vacia
if(!listaActividadMejora.isEmpty()){
// Recorremos la lista
for(ActividadMejora actividadMejora : listaActividadMejora){
// **********************************************
// PROCESO: ACTUALIZACIÓN DE ESTADO
// **********************************************
BigDecimal porcentaje = BigDecimal.ZERO;
// Obtenemos el porcentaje de ejecución
porcentaje = this.calculaPorcentajeEjecucionAM(actividadMejora);
// Indicador de condición de cambio de estado
BigDecimal indicador = new BigDecimal(100);
// Obtenemos el estado inicial de la actividad para determinar si existe o no cambio de estado
EstadoAM estadoInicial = actividadMejora.getEstadoAM();
// Bandera que determina si existe o no cambio de estado
Boolean existeCambioEstado = false;
// Si porcentaje < 100 resultado: "En Proceso"
if(porcentaje.compareTo(indicador) < 0){
if(!estadoInicial.equals(this.obtenerEstadoAMEnProceso())){
actividadMejora.setEstadoAM(this.obtenerEstadoAMEnProceso());
existeCambioEstado = true;
}else{
existeCambioEstado = false;
}
// Si porcentaje == 100 resultado: "Implementada"
}else if(porcentaje.compareTo(indicador) == 0){
if(!estadoInicial.equals(this.obtenerEstadoAMImplementada())){
actividadMejora.setEstadoAM(this.obtenerEstadoAMImplementada());
existeCambioEstado = true;
}else{
existeCambioEstado = false;
}
}
// **********************************************
// PROCESO: ACTUALIZACIÓN DE BITACORA
// **********************************************
// Si existe cambio de estado guardamos
if(existeCambioEstado){
// Guardamos el registro
this.save(actividadMejora);
// Creamos una lista de MetaPoaEvaluacion limpia
List<MetaPoaEvaluacion> listaMetaPoaEvaluacionPorPeriodo = new ArrayList<>();
// Obtenemos la lista de MetaPoaEvaluacion por periodo que viene ordenada por fecha descendente
listaMetaPoaEvaluacionPorPeriodo = obtenerMetaPoaEvaluacionByActividadMejoraAndPeriodoAnual(actividadMejora,planOperativo.getPeriodoAnual());
// Si la lista no esta vacia para el año es decir "existen evaluaciones"
if(!listaMetaPoaEvaluacionPorPeriodo.isEmpty()){
// Se obtiene la justificación de la evaluación
String justificacionEvaluacion = String.valueOf(listaMetaPoaEvaluacionPorPeriodo.get(0).getJustificacion());
// Se guarda el registro en bitacora
this.creaBitacoraAMModificado(actividadMejora,justificacionEvaluacion);
}
}
}
}
}
Probar funcionamiento dentro de Evaluacion Opertativa
EvaluacionOperativaServiceImpl.java
Ahora el método anterior debe ser llamado al momento de actualizar una evaluacion operativa
por esto vamos TEMPORALMENTE a sobre escribir el método «update» para llamar la los metodos de actulización de ARR y AM
