Validación de Procanase

La validación de Procanase permite verificar que la información del trabajador coincida entre RENAPO y PROCANASE antes de realizar una modificación de datos.

Nota

Este proceso es especialmente relevante para trámites de CURP sin liga en RENAPO [Trámite 9B].

Descripción del Proceso

El proceso inicia cuando el asesor previsional detecta diferencias entre el nombre del trabajador en RENAPO y PROCANASE al intentar editar los datos del trabajador.

Paso 1: Detección de Diferencias

Al seleccionar la opción Editar (candadito) en la Consulta 360, el sistema valida automáticamente el nombre del trabajador de RENAPO contra PROCANASE. Si se encuentran diferencias, se muestra el siguiente mensaje:

“Se identifica que el nombre del trabajador encontrado en PROCANASE no concuerda con el de RENAPO. Favor de invitar al trabajador para que acuda al IMSS a realizar su corrección. ¿Desea realizar una Modificación de datos por cambio de CURP considerando la responsabilidad como Afore?”

El asesor puede seleccionar:

• Sí [Continuar]: Continúa con el proceso de ingreso de CURP
• No [Terminar]: Se cierra la ventana y no se permite continuar con el trámite

Paso 2: Ingreso de CURP

Si el asesor selecciona Sí, se habilita el campo para ingresar la nueva CURP a modificar.

Consejo

El sistema valida que la CURP tenga una longitud de 18 caracteres. Si no cumple con la longitud, se muestra el mensaje en rojo: “CURP inválida” [Error]

Paso 3: Consulta CURP en RENAPO

Una vez ingresada una CURP válida, el sistema consulta en RENAPO:

Resultados de la consulta

• Si existe [Válido]: Se obtiene el nombre completo del trabajador y se continúa con la validación
• Si no existe [No encontrado]: Se muestra el mensaje “CURP no registrada en RENAPO” y no se permite continuar

Paso 4: Validación en PROCANASE

El sistema realiza las siguientes validaciones:

1. Validación de CURP: Se verifica que la CURP ingresada sea igual a la registrada en PROCANASE

   • Si no coincide: Se muestra “Se identifica que la información del trabajador encontrada en PROCANASE no concuerda con la de RENAPO”

2. Validación de Nombre: Se compara el nombre completo del trabajador entre RENAPO y PROCANASE

   • Para RENAPO: Se concatena apellido paterno + apellido materno + nombre(s) con el signo $, se trunca a 50 posiciones y se reemplazan caracteres especiales
   • Para PROCANASE: Se reemplazan caracteres especiales
   • Se compara cada elemento del nombre eliminando espacios antes y después

Resultado de la Validación

Validación exitosa

Si la información coincide, se permite el ingreso a la Modificación de Datos [Acceso permitido]

Validación fallida

Si hay diferencias, se muestra el mensaje de error y no se permite continuar con el trámite [Bloqueado]

Flujo del Proceso

graph TD
    A[Asesor selecciona Editar en Consulta 360] --> B{¿Nombre RENAPO = PROCANASE?}
    B -->|Sí| C[Continúa flujo normal de Modificación]
    B -->|No| D[Muestra mensaje de diferencias]
    D --> E{¿Desea continuar con responsabilidad Afore?}
    E -->|No| F[Cierra ventana - Fin del trámite]
    E -->|Sí| G[Ingresa nueva CURP]
    G --> H{¿CURP válida - 18 caracteres?}
    H -->|No| I[Muestra: CURP inválida]
    I --> G
    H -->|Sí| J[Consulta CURP en RENAPO]
    J --> K{¿CURP existe en RENAPO?}
    K -->|No| L[Muestra: CURP no registrada en RENAPO]
    L --> F
    K -->|Sí| M[Obtiene nombre de RENAPO]
    M --> N{¿CURP coincide con PROCANASE?}
    N -->|No| O[Muestra: Información no concuerda]
    O --> F
    N -->|Sí| P{¿Nombre RENAPO = Nombre PROCANASE?}
    P -->|No| O
    P -->|Sí| Q[Permite acceso a Modificación de Datos]

    style A fill:#e1f5ff
    style Q fill:#e1ffe1
    style F fill:#ffe1e1
    style L fill:#ffe1e1
    style O fill:#ffe1e1

Reglas de Comparación de Nombres

Campo	RENAPO	PROCANASE
Formato	Apellido Paterno $ Apellido Materno $ Nombre(s)	Nombre completo
Longitud máxima	50 caracteres	Sin límite
Caracteres especiales	Se reemplazan	Se reemplazan
Espacios	Se conservan internos, se eliminan al inicio y final	Se eliminan al inicio y final

Clases Utilizadas

A continuación se presentan las principales clases que implementan la validación de Procanase:

Controller

Inicialización de Sesión

El controller principal inicializa las variables de sesión necesarias para el flujo de validación de Procanase.

consultaPrincipal.do

// Inicializar variables de sesión para validación de Procanase
request.getSession().setAttribute(ModificacionTrabajadorConstants.CURP_PROCANASE, ModificacionTrabajadorConstants.SIN_CURP_PROCANASE);
request.getSession().setAttribute(ModificacionTrabajadorConstants.DATOS_RENAPO_CURP_NUEVA_PROCANASE, new CURPStruct());

Propósito:

• CURP_PROCANASE: Almacena el estado de validación de CURP contra Procanase
• DATOS_RENAPO_CURP_NUEVA_PROCANASE: Guarda los datos obtenidos de RENAPO para la nueva CURP

ValidacionProcanaseController

Controlador REST que expone el endpoint para validar CURP contra RENAPO y PROCANASE.

@Controller
public class ValidacionProcanaseController {

    @Autowired
    private ValidacionProcanaseService validacionProcanaseService;

    @Autowired
    private SessionService sessionService;

    /**
     * Valida la CURP consultando RENAPO y cotejando contra PROCANASE.
     */
    @PostMapping(value = "/private/validarCurpLigaRenapo",
                 produces = MediaType.APPLICATION_JSON_VALUE,
                 consumes = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public RespuestaOperacionRenapo validarCurpLigaRenapo(@RequestBody String curpBody)
            throws IOException {

        sessionService.setAttribute(
            ModificacionTrabajadorConstants.CURP_PROCANASE,
            ModificacionTrabajadorConstants.SIN_CURP_PROCANASE
        );

        ObjectMapper mapper = new ObjectMapper();
        String curp = mapper.readValue(curpBody, String.class);

        RespuestaOperacionRenapo respuesta =
            validacionProcanaseService.validarCurpContraProcanase(curp);

        return respuesta;
    }
}

Validaciones en Vista (JSP)

El JSP datosGenerales.jsp utiliza la variable de sesión para determinar qué datos mostrar.

Validación CURP

<input class="InputEdit" type="text" id="curp" name="curp"
       value="${existeCurpProcanase != 'SIN_CURP_PROCANASE' ? renapoNuevaProcanase.curp : certificables.curp}"
       placeholder="Curp del trabajador" onchange="actualizaCurp();" maxlength="18">

<script>
    $(document).ready(function() {
        // Verificar si el valor cambió programáticamente
        var valorOriginal = "${certificables.curp}";
        var valorActual = $("#curp").val();

        // Si son diferentes, significa que cambió programáticamente
        if (valorOriginal !== valorActual) {
            actualizaCurp();
        }
    });
</script>

Script de Actualización Automática:

Este script detecta cuando el valor de la CURP ha sido cambiado programáticamente (por la validación de Procanase) y ejecuta automáticamente la función actualizaCurp() para actualizar todos los campos dependientes:

• Compara el valor original (certificables.curp) con el valor actual del campo
• Si son diferentes, significa que se cargaron datos de RENAPO
• Ejecuta actualizaCurp() para propagar los cambios a nombre, apellidos, fecha de nacimiento, etc.

Validación Nombre

<input class="InputEdit" type="text" id="nombre" name="nombre"
       value="${existeCurpProcanase != 'SIN_CURP_PROCANASE' ? renapoNuevaProcanase.nombres : certificables.nombre}"
       placeholder="Nombre del trabajador" maxlength="50">

Validación Apellidos

<!-- Apellido Paterno -->
<input class="InputEdit" type="text" id="apellidoPaterno" name="apellidoPaterno"
       value="${existeCurpProcanase != 'SIN_CURP_PROCANASE' ? renapoNuevaProcanase.apellido1 : certificables.apellidoPaterno}"
       placeholder="Apellido Paterno del trabajador" maxlength="50">

<!-- Apellido Materno -->
<input class="InputEdit" type="text" id="apellidoMaterno" name="apellidoMaterno"
       value="${existeCurpProcanase != 'SIN_CURP_PROCANASE' ? renapoNuevaProcanase.apellido2 : certificables.apellidoMaterno}"
       placeholder="Apellido Materno del trabajador" maxlength="50">

Validación Fecha de Nacimiento

<c:if test="${existeCurpProcanase != 'SIN_CURP_PROCANASE'}">
    <fmt:parseDate value="${renapoNuevaProcanase.fechNac}" pattern="dd/MM/yyyy" var="fechaParseada" />
    <c:set var="fechaFormateada"><fmt:formatDate value="${fechaParseada}" pattern="yyyy-MM-dd" /></c:set>
</c:if>

<input class="InputEdit" type="date" id="fechaNacimiento" name="fechaNacimiento"
       value="${existeCurpProcanase != 'SIN_CURP_PROCANASE' ? fechaFormateada : fechaNacimiento}">

Validación Género

<c:choose>
    <c:when test="${existeCurpProcanase != 'SIN_CURP_PROCANASE'}">
        <c:choose>
            <c:when test="${renapoNuevaProcanase.sexo == 'H'}">
                <c:set var="generoEvaluado" value="M" />
            </c:when>
            <c:when test="${renapoNuevaProcanase.sexo == 'M'}">
                <c:set var="generoEvaluado" value="F" />
            </c:when>
            <c:otherwise>
                <c:set var="generoEvaluado" value="X" />
            </c:otherwise>
        </c:choose>
    </c:when>
    <c:otherwise>
        <c:set var="generoEvaluado" value="${claveGeneroLimpia}" />
    </c:otherwise>
</c:choose>

Lógica de Validación:

Si existeCurpProcanase != 'SIN_CURP_PROCANASE':

• ✅ Se muestran los datos obtenidos de RENAPO (renapoNuevaProcanase)
• ✅ Indica que la validación con Procanase fue exitosa

Si existeCurpProcanase == 'SIN_CURP_PROCANASE':

• ✅ Se muestran los datos originales del trabajador (certificables)
• ✅ Indica que no se ha validado o la validación falló

Service

ValidacionProcanaseServiceImpl

Servicio orquestador que coordina el flujo completo de validación entre RENAPO y PROCANASE.

@Service
public class ValidacionProcanaseServiceImpl implements ValidacionProcanaseService {

    @Autowired
    private RenapoService renapoService;

    @Autowired
    private ConsultaPersonaProcanaseService consultaPersonaService;

    @Autowired
    private ConsultaCanaseService consultaCanaseService;

    @Autowired
    private ValidacionNombreProcanaseService validacionNombreService;

    @Override
    public RespuestaOperacionRenapo validarCurpContraProcanase(String curp) {
        RespuestaOperacionRenapo respuesta = new RespuestaOperacionRenapo();
        respuesta.setExisteError(Boolean.FALSE);

        try {
            // 1. Consultar datos en RENAPO
            CURPStruct renapo = renapoService.obtenerDatosRenapoPorCurp(curp);

            // 2. Validar respuesta de RENAPO
            if (!validacionRespuestaRenapoService.esRespuestaValida(renapo)) {
                return respuesta;
            }

            // 3. Obtener información de persona
            PersonaSalida persona = consultaPersonaService.obtenerPersonaPorCurp(curp);

            // 4. Validar tipo de afiliación IMSS
            if (!validacionTipoAfiliacionService.esTipoAfiliacionImss(
                    persona.getTipoAfiliacion())) {
                return respuesta;
            }

            // 5. Consultar datos en CANASE
            Canase canase = consultaCanaseService.consultarPorNss(persona.getNss());

            // 6. Validar coincidencia de nombres
            boolean nombresCoinciden = validacionNombreService
                .validarCoincidenciaNombres(renapo, canase.getNombreImss());

            if (!nombresCoinciden) {
                marcarCurpComoInvalida();
                throw new BusinessException(
                    "La información del trabajador en PROCANASE no concuerda con RENAPO"
                );
            }

            // Guardar CURP validada en sesión
            sessionService.setAttribute(
                ModificacionTrabajadorConstants.CURP_PROCANASE, curp
            );

        } catch (BusinessException e) {
            respuesta.setExisteError(Boolean.TRUE);
            respuesta.setDescripcion(e.getMessage());
        }

        return respuesta;
    }
}

JavaScript

remediacion.js

Funciones JavaScript que manejan la validación en el frontend.

Validación Principal

async function validarConsultaPreviaParaConsultarCurpEnRemediacion(
    link, curpTrabajador, nssTrabajador
) {
    bloquearEnlace(link);
    globalThis.location.href = "#modalLoader";

    // Validar proceso pendiente RENAPO
    let resultadoValidacion = await validarProcesoPendienteRenapo(
        link, curpTrabajador, nssTrabajador
    );

    if (resultadoValidacion) {
        desbloquearEnlace(link);
        globalThis.location.href = "#";
        return false;
    }

    // Validar CURP con RENAPO
    let validacionRenapo = await validarCurpRenapo(link, curpTrabajador);

    if (!validacionRenapo) {
        desbloquearEnlace(link);
        globalThis.location.href = "#";
        return false;
    }

    // Continuar con validación de expediente...
}

Validación CURP con RENAPO y PROCANASE

async function validarCurpLigaRenapo(link, curp) {
    bloquearEnlace(link);
    globalThis.location.href = "#modalLoader";

    try {
        const response = await fetch(
            contexto + '/private/validarCurpLigaRenapo',
            {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(curp)
            }
        );

        const data = await response.json();
        globalThis.location.href = "#";

        if (data.existeError) {
            desbloquearEnlace(link);

            await Swal.fire({
                title: 'Aviso',
                text: data.descripcion,
                icon: 'warning',
                confirmButtonText: 'De acuerdo'
            });

            return;
        }

        // Continuar con flujo de remediación
        consultarCurpEnRemediacion(link, curp);

    } catch (error) {
        console.error('Error al validar CURP:', error);
        desbloquearEnlace(link);

        Swal.fire({
            title: 'Error',
            text: 'Error al validar la CURP con RENAPO',
            icon: 'error'
        });
    }
}

Validación de Nombres RENAPO vs CANASE

function validarNombreRenapoCanase(link, curpTrabajador) {
    bloquearEnlace(link);

    $.ajax({
        method: "GET",
        url: "validarNombreRenapoProCanase.do",
        contentType: "application/json",
        async: false,
        data: { curpTrabajador: curpTrabajador }
    })
    .success(function (data) {
        if (data.flujo == 1) {
            // Nombres no coinciden - Mostrar alerta
            Swal.fire({
                title: 'Aviso',
                html: data.mensaje + '<br><br>¿Desea realizar una ' +
                      'Modificación de datos por cambio de CURP?',
                icon: 'warning',
                showCancelButton: true,
                confirmButtonText: 'Sí',
                cancelButtonText: 'No'
            }).then(function(result) {
                if (result.isConfirmed) {
                    mostrarInputCurp(link);
                } else {
                    desbloquearEnlace(link);
                }
            });
        } else if (data.flujo == 0 || data.flujo == 2) {
            // Nombres coinciden - Continuar
            consultarCurpEnRemediacion(link, curpTrabajador);
        }
    })
    .fail(function (jqXHR, textStatus) {
        Swal.fire({
            title: '',
            text: 'No es posible realizar la consulta',
            icon: 'error'
        });
    });
}

Recursos

Servicios Auxiliares

Los siguientes servicios especializados son utilizados por el servicio principal:

Servicio	Responsabilidad
ValidacionRespuestaRenapoService	Valida que la respuesta de RENAPO sea válida y exitosa
ValidacionTipoAfiliacionService	Verifica que el tipo de afiliación sea IMSS
ValidacionDatosCanaseService	Valida que los datos de CANASE sean correctos
ValidacionNombreProcanaseService	Compara y valida la coincidencia de nombres
ConsultaPersonaProcanaseService	Obtiene información de persona por CURP
ConsultaCanaseService	Consulta datos del trabajador en CANASE

Patrón de Arquitectura

Servicios Especializados

La implementación sigue el patrón de Servicios Especializados, donde cada servicio tiene una responsabilidad única y bien definida, facilitando el mantenimiento y las pruebas unitarias.

Endpoints REST

Endpoint	Método	Descripción
/private/validarCurpLigaRenapo	POST	Valida CURP contra RENAPO y PROCANASE
/private/validarConsultaPrincipalRenapo	POST	Valida consulta principal en RENAPO
/private/validarProcesoPendienteRenapo	POST	Verifica procesos pendientes

Caso de Prueba Productivo

1. Resumen del Escenario de Prueba

Este conjunto de pruebas valida la integridad de la información del trabajador al realizar una modificación de datos por cambio de CURP, asegurando la consistencia entre los registros de RENAPO y PROCANASE.

Escenario de Referencia: Caso Real Afore Banamex

Este escenario sirve como base para entender la discrepancia que el sistema debe detectar.

Caso Detectado en Producción:

Campo	Valor
CURP en RENAPO	Certificada y vigente
Nombre en RENAPO	LAURA CANO LOBERA
Nombre en PROCANASE	LAURA PATRICIA CANO LOBERA
Diferencia	Segundo nombre “Patricia”
Resultado Esperado	Bloqueo del trámite y lanzamiento del modal de aviso

Puntos Críticos a Validar:

• ✅ Detección de CURP’s asociadas: El sistema debe identificar si el trabajador tiene registros previos (ej. CALL691104MDFNBR11)
• ✅ Mensaje de Bloqueo: Debe aparecer exactamente el texto: “SE IDENTIFICA QUE EL NOMBRE DEL TRABAJADOR ENCONTRADO EN PROCANASE NO CONCUERDA CON EL DE RENAPO. FAVOR DE INVITAR AL TRABAJADOR…“

2. Ambientación de Datos (Ambiente Pre-Producción)

Importante

Los datos deben corresponder al ambiente de preproducción dado que este es un registro de desarrollo y posiblemente cambien algunos valores como ID, PK o FK.

Tabla: NSAR_TR_TRAB_CANASE (PROCANASE)

Campo	Valor
ID_PROCESAR	968
CH_MES_NACIMIENTO	11
CH_NOMBRE_IMSS	CANO$LOBERA$LAURA
CH_SEXO	F
CH_USUARIO_MODIFICADOR	SDHERNAN
CH_CLASIF_NSS	0
CURP	CALL641104MDFNBR08
ID_ENTIDAD_NACIMIENTO	10
NSS	20946905237

Tabla: NSAR_TR_PERSONA

Campo	Valor
ID_PROCESAR	968
CH_APELLIDO_PATERNO	CANO
CH_APELLIDO_MATERNO	LOBERA
CH_NOMBRE	LAURA PATRICIA
FC_NACIMIENTO	1969-11-04 00:00:00.000
CH_SEXO	F
NSS	20946905237
CURP	CALL691104MDFNBR03
ID_ENTIDAD_NACIMIENTO	10

3. Casos de Prueba

Caso de Prueba 1: Validación de Diferencias en Nombres (HU_PLAT_ICVP - CA011)

Referencia

HU_Ingresar CURP para validación PROCANASE

Descripción: Validar que el sistema detecte inconsistencias entre el nombre registrado en RENAPO vs PROCANASE al intentar editar los datos.

Pasos:

1. Ingresar a la Consulta 360
2. Seleccionar la opción Editar (Icono de candado)
3. El sistema realiza la validación automática entre RENAPO y PROCANASE

Resultado Esperado:

• ✅ MENSAJE DE ALERTA: Debe mostrar el aviso de no concordancia
• ✅ FLUJO ALTERNO: Debe incluir la pregunta de si desea continuar con el trámite si la AFORE así lo decide

Caso de Prueba 2: Regla de Comparación de Nombres (Backend)

Descripción: Validar la lógica de backend para la comparación de cadenas de texto.

Regla (Backend):

1. RENAPO: ApellidoPaterno $ ApellidoMaterno $ Nombre (Truncado a 50 caracteres)
2. Limpieza: Eliminar caracteres especiales y espacios innecesarios

Resultado Esperado:

Si tras la concatenación y limpieza (usando el separador $) los nombres no son idénticos al 100%, el sistema debe bloquear el acceso a la pantalla de Modificación.

4. Matriz de Mensajes y Validaciones (Referencia Rápida)

Campo / Acción	Validación	Mensaje Esperado
Longitud CURP	!= 18 caracteres	🔴 CURP inválida
Búsqueda RENAPO	No existe registro	CURP no registrada en RENAPO…
Diferencia Nombres	No coinciden	SE IDENTIFICA QUE EL NOMBRE… NO CONCUERDA…

5. Evidencia Requerida para QA

Screenshots necesarios:

1. 📸 Screenshot 1: Consulta 360 con el icono de candado
2. 📸 Screenshot 2: Modal de Advertencia
3. 📸 Screenshot 3: Validación de campo CURP con 17 caracteres (Mensaje en rojo)
4. 📸 Screenshot 4: Si el proceso se continúa por parte de la afore debe ir por un flujo 9B

Flujo Alternativo

Si el proceso se continúa por parte de la AFORE, debe seguir el flujo 9B (CURP sin liga en RENAPO).