SistemaMantenimiento/sistema-mantenimiento-back/app/Http/Controllers/ProcessManagementController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use ElephantIO\Client;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Log;


class ProcessManagementController extends Controller
{
    private $responseController;
    private $encController;
    private $resourcesController;
    private $documentManagementController;
    private $functionsController;

    private $notificationsController;
    private $socketClient;

    public function __construct()
    {
        $this->responseController = new ResponseController();
        $this->encController = new EncryptionController();
        $this->resourcesController = new ResourcesController();
        $this->documentManagementController = new DocumentManagementController();
        $this->functionsController = new FunctionsController();

        $this->notificationsController = new NotificationsController();

        $url = 'http://localhost:3200';
        $this->socketClient = new Client(Client::engine(Client::CLIENT_4X, $url));
        $this->socketClient->initialize();
        $this->socketClient->of('/');
    }

    //Submódulo de gestión de workflows 

    public function registerWorkflow(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'NOMBRE_WORKFLOW' => 'required|string|max:50',
            'DESCRIPCION' => 'required|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        try {
            $workflowId = DB::table('S002V01TWORK')->insertGetId([
                'WORK_NULI' => $requestData['NUMERO_LINEA'],
                'WORK_NOWO' => $requestData['NOMBRE_WORKFLOW'],
                'WORK_DESC' => $requestData['DESCRIPCION'],
                'WORK_PRED' => false,
                'WORK_ESTA' => 'Borrador',
                'WORK_VERS' => 1,
                'WORK_USRE' => $user,
                'WORK_FERE' => $currentDate,
                'WORK_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al registrar el workflow.", $th->getMessage(), 500);
        }

        DB::commit();
        $this->functionsController->registerActivity(
            $requestData['NUMERO_LINEA'],
            'S002V01M03GEPR',
            'S002V01F01GFTR',
            'S002V01P01PCIN',
            'Registro',
            "El usuario (" . $user . ") registró un flujo de trabajo.",
            $user,
            $this->functionsController->now(),
            null,
            $workflowId

        );
        return $this->responseController->makeResponse(false, "ÉXITO: Workflow registrado exitosamente", ['ID_WORKFLOW' => $workflowId]);
    }

    public function registerWorkflowTask(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'ID_WORKFLOW' => 'required|integer',
            'NOMBRE_TAREA' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'SECUENCIA' => 'required|integer',
            'REQUIERE_VALIDACION' => 'nullable|boolean',
            'USUARIOS_NOTIFICAR' => 'array',
            'USUARIO_VALIDADOR' => 'array',
            'REGLAS_VALIDACION' => 'string|in:Esperar,Ejecutar,NA',
            'ID_FUNCION' => 'nullable|string',
            'ID_MODULO' => 'nullable|string',
            'ID_SUBMODULO' => 'nullable|string',
            'ID_WORKFLOW_EJECUTAR' => 'nullable|integer',
            'INTERVALO' => 'nullable|integer',
            'UNIDAD' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        Log::info($request);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $decryptMod = $this->encController->decrypt($requestData['ID_MODULO']);
        if (!$decryptMod) {
            return $this->responseController->makeResponse(true, "ID_MODULO no fue desencriptada correctamente", [], 400);
        }

        $decryptSubMod = null;
        if (!empty($requestData['ID_SUBMODULO'])) {
            $decryptSubMod = $this->encController->decrypt($requestData['ID_SUBMODULO']);
            if (!$decryptSubMod) {
                return $this->responseController->makeResponse(true, "ID_SUBMODULO no fue desencriptada correctamente", [], 400);
            }
        }

        $user = $arrResponseCheckUser['response'];

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        Log::info($requestData);

        $informacionExtra = $this->processExtraInfo(
            $requestData['REGLAS_VALIDACION'],
            $requestData
        );

        try {
            $taskId = DB::table('S002V01TTAWO')->insertGetId([
                'TAWO_NULI' => $requestData['NUMERO_LINEA'],
                'TAWO_IDWO' => $requestData['ID_WORKFLOW'],
                'TAWO_NOTA' => $requestData['NOMBRE_TAREA'],
                'TAWO_DESC' => $requestData['DESCRIPCION'],
                'TAWO_SECU' => $requestData['SECUENCIA'],
                'TAWO_RQVA' => $requestData['REQUIERE_VALIDACION'],
                'TAWO_USAN' => json_encode($requestData['USUARIOS_NOTIFICAR']),
                'TAWO_USAV' => json_encode($requestData['USUARIO_VALIDADOR']),
                'TAWO_REVA' => $requestData['REGLAS_VALIDACION'],
                'TAWO_IDFU' => $requestData['ID_FUNCION'],
                'TAWO_IDMO' => $decryptMod,
                'TAWO_IDSM' => $decryptSubMod,
                'TAWO_INEX' => $informacionExtra,
                'TAWO_ESTA' => 'Borrador',
                'TAWO_USRE' => $user,
                'TAWO_FERE' => $currentDate,
                'TAWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la tarea.", $th->getMessage(), 500);
        }

        DB::commit();
        $this->functionsController->registerActivity(
            $requestData['NUMERO_LINEA'],
            'S002V01M03GEPR',
            'S002V01F01GETA',
            'S002V01P01PCIN',
            'Registro',
            "El usuario (" . $user . ") registró una tarea.",
            $user,
            $this->functionsController->now(),
            null,
            $requestData['ID_WORKFLOW'] //EN ESTE ESPECIFICO CASO ID_WORKFLOW ES EL VALOR ANCLA
        );
        return $this->responseController->makeResponse(false, "ÉXITO: Tarea registrada exitosamente", ['ID_TAREA' => $taskId]);
    }

    public function getWorkflows($user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {

            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrWorkflows = DB::Table('v_workflows_modulos_simple')->get();
            $arrWorkflows = json_decode(json_encode($arrWorkflows), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los flujos de trabajo.", $th->getMessage(), 500);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrWorkflows);
    }

    public function getActiveWorkflows($user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrWorkflows = DB::table('S002V01TWORK')
                ->where('WORK_NULI', '=', $line)
                ->where('WORK_ESTA', '=', 'Activo')
                ->get([
                    'WORK_IDWO AS ID_WORKFLOW',
                    'WORK_NOWO AS NOMBRE_WORKFLOW',
                    'WORK_DESC AS DESCRIPCION'
                ]);
            $arrWorkflows = json_decode(json_encode($arrWorkflows), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los flujos de trabajo activos.", $th->getMessage(), 500);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrWorkflows);
    }

    public function getWorkflowById($idWorkflow, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        /*
        try {
            $idWorkflow = $this->encController->decrypt($idWorkflow);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }*/

        try {
            $result = DB::select("SELECT fn_get_workflow_by_id(?) as workflow_data", [$idWorkflow]);
            $workflowData = json_decode($result[0]->workflow_data, true);

            $workflow = $workflowData['workflow'];

            $formattedWorkflow = [
                'ID_WORKFLOW' => $workflow['ID_WORKFLOW'],
                'NOMBRE_WORKFLOW' => $workflow['NOMBRE_WORKFLOW'],
                'DESCRIPCION' => $workflow['DESCRIPCION'],
                'PREDETERMINADO' => $workflow['PREDETERMINADO'],
                'ESTADO' => $workflow['ESTADO'],
                'VERSION' => $workflow['VERSION'],
                'INFORMACION_EXTRA' => json_encode($workflow['INFORMACION_EXTRA']),
                'MODULOS' => $workflowData['MODULOS'],
                'USUARIO_REGISTRO' => $workflow['USUARIO_REGISTRO'],
                'FECHA_REGISTRO' => $workflow['FECHA_REGISTRO'],
                'USUARIO_MODIFICA' => $workflow['USUARIO_MODIFICA'],
                'FECHA_MODIFICA' => $workflow['FECHA_MODIFICA']
            ];

            $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate([$formattedWorkflow], $line);
            if ($responseCheckLatestUpdate['error']) {
                return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
            }
            $formattedWorkflow = $responseCheckLatestUpdate['response'][0];
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los flujos de trabajo.", $th->getMessage(), 500);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $formattedWorkflow);
    }

    public function updateWorkflow(Request $request, $idWorkflow)
    {
        $validator = Validator::make($request->all(), [
            'NOMBRE_WORKFLOW' => 'required|string|max:50',
            'DESCRIPCION' => 'required|string',
            'COMENTARIO_CAMBIO' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        /*
        try {
            $idWorkflow = $this->encController->decrypt($idWorkflow);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el ID del workflow', $th->getMessage(), 406);
        }*/

        try {
            $currentWorkflow = (array) DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first([
                    'WORK_NOWO',
                    'WORK_DESC',
                    'WORK_VERS'
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el workflow.", $th->getMessage(), 500);
        }

        if (empty($currentWorkflow)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "El workflow no existe.", [], 404);
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();
        $newVersion = $currentWorkflow['WORK_VERS'] + 1;

        // try {
        //     DB::table('S002V01THWORK')->insert([
        //         'HWORK_IDWO' => $idWorkflow,
        //         'HWORK_VERS' => $currentWorkflow['WORK_VERS'],
        //         'HWORK_NOWO' => $currentWorkflow['WORK_NOWO'],
        //         'HWORK_DESC' => $currentWorkflow['WORK_DESC'],
        //         'HWORK_COME' => $requestData['COMENTARIO_CAMBIO'],
        //         'HWORK_USRE' => $user,
        //         'HWORK_FERE' => $currentDate,
        //         'HWORK_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
        //     ]);
        // } catch (\Throwable $th) {
        //     DB::rollBack();
        //     return $this->responseController->makeResponse(true, "Ocurrió un error al registrar el historial.", $th->getMessage(), 500);
        // }

        try {
            $validateUpdate = DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'WORK_NOWO' => $requestData['NOMBRE_WORKFLOW'],
                    'WORK_DESC' => $requestData['DESCRIPCION'],
                    'WORK_VERS' => $newVersion,
                    'WORK_USMO' => $user,
                    'WORK_FEMO' => $currentDate,
                    'WORK_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al actualizar el workflow.", $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo actualizar el workflow.", [], 500);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Workflow actualizado exitosamente");
    }

    public function changeWorkflowStatus(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'ESTADO' => 'required|string|in:Activo,Eliminado',
            'COMENTARIO_CAMBIO' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
            'ID_WORKFLOW' => 'required|integer'
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        try {
            $currentWorkflow = (array) DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first([
                    'WORK_NOWO',
                    'WORK_DESC',
                    'WORK_ESTA',
                    'WORK_VERS'
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el workflow.", $th->getMessage(), 500);
        }

        if (empty($currentWorkflow)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "El workflow no existe.", [], 404);
        }

        if ($currentWorkflow['WORK_ESTA'] === $requestData['ESTADO']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "El workflow ya tiene el estado solicitado.", [], 400);
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        // try {
        //     DB::table('S002V01THWORK')->insert([
        //         'HWORK_IDWO' => $requestData['ID_WORKFLOW'],
        //         'HWORK_VERS' => $currentWorkflow['WORK_VERS'],
        //         'HWORK_NOWO' => $currentWorkflow['WORK_NOWO'],
        //         'HWORK_DESC' => $currentWorkflow['WORK_DESC'],
        //         'HWORK_COME' => $requestData['COMENTARIO_CAMBIO'] ?? 'Cambio de estado a: ' . $requestData['ESTADO'],
        //         'HWORK_USRE' => $user,
        //         'HWORK_FERE' => $currentDate,
        //         'HWORK_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
        //     ]);
        // } catch (\Throwable $th) {
        //     DB::rollBack();
        //     return $this->responseController->makeResponse(true, "Ocurrió un error al registrar el historial.", $th->getMessage(), 500);
        // }

        // try {
        //     DB::table('S002V01THEWO')->insert([
        //         'HEWO_IDWO' => $requestData['ID_WORKFLOW'],
        //         'HEWO_ESTA' => $requestData['ESTADO'],
        //         'HEWO_USRE' => $user,
        //         'HEWO_FECH' => $currentDate,
        //         'HEWO_COME' => $requestData['COMENTARIO_CAMBIO'],
        //     ]);
        // } catch (\Throwable $th) {
        //     DB::rollBack();
        //     return $this->responseController->makeResponse(true, "Ocurrió un error al registrar el historial de estados.", $th->getMessage(), 500);
        // }

        // Actualizar estado del workflow
        try {
            $validateUpdate = DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'WORK_ESTA' => $requestData['ESTADO'],
                    'WORK_USMO' => $user,
                    'WORK_FEMO' => $currentDate,
                    'WORK_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al cambiar el estado del workflow.", $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo cambiar el estado del workflow.", [], 500);
        }

        // Actualizar estado de las tareas relacionadas
        $taskStatus = null;
        if ($currentWorkflow['WORK_ESTA'] === 'Borrador' && $requestData['ESTADO'] === 'Activo') {
            $taskStatus = 'Activo';
        } elseif ($currentWorkflow['WORK_ESTA'] === 'Activo' && $requestData['ESTADO'] === 'Eliminado') {
            $taskStatus = 'Eliminado';
        }

        if ($taskStatus) {
            try {
                DB::table('S002V01TTAWO')
                    ->where('TAWO_IDWO', '=', $requestData['ID_WORKFLOW'])
                    ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->update([
                        'TAWO_ESTA' => $taskStatus,
                        'TAWO_USMO' => $user,
                        'TAWO_FEMO' => $currentDate,
                        'TAWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "Ocurrió un error al actualizar el estado de las tareas.", $th->getMessage(), 500);
            }
        }

        DB::commit();
        $this->functionsController->registerActivity(
            $requestData['NUMERO_LINEA'],
            'S002V01M03GEPR',
            'S002V01F01GSFT',
            'S002V01P01PCIN',
            'Registro',
            "El usuario (" . $user . ") cambio el estado de un flujo de trabajo.",
            $user,
            $this->functionsController->now(),
            null,
            $request['ID_WORKFLOW']
        );
        return $this->responseController->makeResponse(false, "ÉXITO: Estado del workflow cambiado exitosamente");
    }

    public function getWorkflowHistory($idWorkflow, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        /*
        try {
            $idWorkflow = $this->encController->decrypt($idWorkflow);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el ID del workflow', $th->getMessage(), 406);
        }*/

        try {
            $arrHistory = DB::table('S002V01THWORK')
                ->where('HWORK_IDWO', '=', $idWorkflow)
                ->orderBy('HWORK_VERS', 'DESC')
                ->get([
                    'HWORK_VERS AS VERSION',
                    'HWORK_NOWO AS NOMBRE',
                    'HWORK_DESC AS DESCRIPCION',
                    'HWORK_COME AS COMENTARIO',
                    'HWORK_USRE AS USUARIO_CAMBIO',
                    'HWORK_FERE AS FECHA_CAMBIO'
                ]);
            $arrHistory = json_decode(json_encode($arrHistory), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el historial del workflow.", $th->getMessage(), 500);
        }

        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate($arrHistory, $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrHistory = $responseCheckLatestUpdate['response'];

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrHistory);
    }

    public function getTaskByWorkflow($idWorkflow, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        /*
        $idWorkflow = $this->encController->decrypt($idWorkflow);
        if (is_null($idWorkflow)) {
            return $this->responseController->makeResponse(true, 'El flujo de trabajo no está encriptado correctamente.', [], 500);
        }*/

        try {
            $arrTask = DB::table('S002V01TTAWO')->select([
                'TAWO_IDTA AS ID_TAREA',
                'TAWO_NOTA AS NOMBRE_TAREA',
                'TAWO_DESC AS DESCRIPCION',
                'TAWO_SECU AS SECUENCIA',
                'TAWO_RQVA AS REQUIERE_VALIDACION',
                'TAWO_REVA AS REGLA_VALIDACION',
                'TAWO_ESTA AS ESTADO'
            ])->where([
                ['TAWO_IDWO', '=', $idWorkflow],
                ['TAWO_NULI', '=', $line],
            ])->get()->all();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las tareas del flujo de trabajo.', [], 500);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $arrTask);
    }

    public function getTaskById($idTask, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        /*
        $idTask = $this->encController->decrypt($idTask);
        if (is_null($idTask)) {
            return $this->responseController->makeResponse(true, 'El identificador no se encuentra encriptado correctamente.', [], 401);
        }*/

        try {
            $arrTask = DB::table('S002V01TTAWO as TAWO')
                ->leftJoin('S002V01TMODU as TMODU', 'TMODU.MODU_IDMO', '=', 'TAWO.TAWO_IDMO')
                ->leftJoin('S002V01TFUNC as TFUNC', 'TFUNC.FUNC_IDFU', '=', 'TAWO.TAWO_IDFU')
                ->leftJoin('S002V01TSUBM as TSUBM', 'TSUBM.SUBM_IDSM', '=', 'TAWO.TAWO_IDSM')
                ->select([
                    'TAWO.TAWO_IDTA as ID_TAREA',
                    'TAWO.TAWO_NULI as NUMERO_LINEA',
                    'TAWO.TAWO_IDWO as ID_WORKFLOW',
                    'TAWO.TAWO_NOTA as NOMBRE_TAREA',
                    'TAWO.TAWO_DESC as DESCRIPCION',
                    'TAWO.TAWO_SECU as SECUENCIA',
                    'TAWO.TAWO_RQVA as REQUIERE_VALIDACION',
                    'TAWO.TAWO_USAN as USUARIOS_NOTIFICAR_RAW',
                    'TAWO.TAWO_USAV as USUARIO_VALIDADOR_RAW',
                    'TAWO.TAWO_REVA as REGLAS_VALIDACION',
                    'TFUNC.FUNC_NOMB as ID_FUNCION',
                    'TMODU.MODU_NOMO as ID_MODULO',
                    'TSUBM.SUBM_NOMB as ID_SUBMODULO',
                    'TAWO.TAWO_ESTA as ESTADO',
                    'TAWO.TAWO_INEX as INFORMACION_EXTRA',
                    'TAWO.TAWO_USRE as USUARIO_REGISTRO',
                    'TAWO.TAWO_FERE as FECHA_REGISTRO',
                    'TAWO.TAWO_USMO as USUARIO_MODIFICA',
                    'TAWO.TAWO_FEMO as FECHA_MODIFICA',
                    'TAWO.TAWO_FEAR as FECHA_ACTUALIZACION'
                ])
                ->where('TAWO.TAWO_IDTA', $idTask)
                ->where('TAWO.TAWO_NULI', $line)
                ->first();

            if (empty($arrTask)) {
                return $this->responseController->makeResponse(true, "La tarea no existe.", [], 500);
            }

            $arrTask = (array) $arrTask;

            // Procesar usuarios notificadores
            $usuariosNotificar = [];
            if (!empty($arrTask['USUARIOS_NOTIFICAR_RAW'])) {
                $idsNotificar = json_decode($arrTask['USUARIOS_NOTIFICAR_RAW'], true) ?: [];
                if (!empty($idsNotificar)) {
                    $usuarios = DB::table('S002V01TUSUA')
                        ->whereIn('USUA_IDUS', $idsNotificar)
                        ->get(['USUA_IDUS', 'USUA_NOMB']);
                    foreach ($usuarios as $usuario) {
                        $usuariosNotificar[] = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                    }
                }
            }
            $arrTask['USUARIOS_NOTIFICAR'] = implode(', ', $usuariosNotificar);

            // Procesar usuarios validadores
            $usuariosValidador = [];
            if (!empty($arrTask['USUARIO_VALIDADOR_RAW'])) {
                $idsValidador = json_decode($arrTask['USUARIO_VALIDADOR_RAW'], true) ?: [];
                if (!empty($idsValidador)) {
                    $usuarios = DB::table('S002V01TUSUA')
                        ->whereIn('USUA_IDUS', $idsValidador)
                        ->get(['USUA_IDUS', 'USUA_NOMB']);
                    foreach ($usuarios as $usuario) {
                        $usuariosValidador[] = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                    }
                }
            }
            $arrTask['USUARIO_VALIDADOR'] = implode(', ', $usuariosValidador);

            // Remover campos temporales
            unset($arrTask['USUARIOS_NOTIFICAR_RAW'], $arrTask['USUARIO_VALIDADOR_RAW']);

            $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate([$arrTask], $line);
            if ($responseCheckLatestUpdate['error']) {
                return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
            }
            $arrTask = $responseCheckLatestUpdate['response'][0];
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas.", $th->getMessage(), 500);
        }

        // Extraer información extra según regla de validación
        $idWorkflowEjecutar = null;
        $intervalo = null;
        $unidad = null;

        if (!empty($arrTask['INFORMACION_EXTRA'])) {
            $infoExtra = json_decode($arrTask['INFORMACION_EXTRA'], true);
            if ($arrTask['REGLAS_VALIDACION'] === 'Esperar' && $infoExtra) {
                $intervalo = $infoExtra['intervalo'] ?? null;
                $unidad = $infoExtra['unidad'] ?? null;
            } elseif ($arrTask['REGLAS_VALIDACION'] === 'Ejecutar' && $infoExtra) {
                $idWorkflowEjecutar = $infoExtra['workflow_id'] ?? null;
            }
        }

        $arrTask['ID_WORKFLOW_EJECUTAR'] = $idWorkflowEjecutar;
        $arrTask['INTERVALO'] = $intervalo;
        $arrTask['UNIDAD'] = $unidad;

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrTask);
    }

    public function getTaskConfiguration($idTask, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        // $idTask = $this->encController->decrypt($idTask);
        // if (is_null($idTask)) {
        //     return $this->responseController->makeResponse(true, 'El identificador no se encuentra encriptado correctamente.', [], 401);
        // }

        try {
            $arrTask = (array) DB::select("
                SELECT 
                    TAWO.TAWO_IDWO AS ID_WORKFLOW,
                    TAWO.TAWO_NOTA AS NOMBRE_TAREA,
                    TAWO.TAWO_DESC AS DESCRIPCION,
                    TAWO.TAWO_SECU AS SECUENCIA,
                    TAWO.TAWO_RQVA AS REQUIERE_VALIDACION,
                    TAWO.TAWO_USAN AS USUARIOS_NOTIFICAR,
                    TAWO.TAWO_USAV AS USUARIO_VALIDADOR,
                    TAWO.TAWO_REVA AS REGLAS_VALIDACION,
                    TAWO.TAWO_IDFU AS ID_FUNCION,
                    TFUNC.FUNC_NOMB AS NOMBRE_FUNCION,
                    TAWO.TAWO_IDMO AS ID_MODULO,
                    TMODU.MODU_NOMO AS NOMBRE_MODULO,
                    TAWO.TAWO_IDSM AS ID_SUBMODULO,
                    TSUBM.SUBM_NOMB AS NOMBRE_SUBMODULO,
                    TAWO.TAWO_INEX AS INFORMACION_EXTRA
                FROM S002V01TTAWO AS TAWO
                LEFT JOIN S002V01TFUNC AS TFUNC ON TFUNC.FUNC_IDFU = TAWO.TAWO_IDFU
                LEFT JOIN S002V01TMODU AS TMODU ON TMODU.MODU_IDMO = TAWO.TAWO_IDMO
                LEFT JOIN S002V01TSUBM AS TSUBM ON TSUBM.SUBM_IDSM = TAWO.TAWO_IDSM
                WHERE TAWO.TAWO_IDTA = ?
                  AND TAWO.TAWO_NULI = ?
            ", [$idTask, $line]);

            $arrTask = !empty($arrTask) ? (array) $arrTask[0] : [];
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener la configuración de la tarea.", $th->getMessage(), 500);
        }

        if (empty($arrTask)) {
            return $this->responseController->makeResponse(true, "La tarea no existe.", [], 404);
        }

        // Extraer información extra según regla de validación
        $idWorkflowEjecutar = null;
        $intervalo = null;
        $unidad = null;

        if (!empty($arrTask['INFORMACION_EXTRA'])) {
            $infoExtra = json_decode($arrTask['INFORMACION_EXTRA'], true);
            if ($arrTask['REGLAS_VALIDACION'] === 'Esperar' && $infoExtra) {
                $intervalo = $infoExtra['intervalo'] ?? null;
                $unidad = $infoExtra['unidad'] ?? null;
            } elseif ($arrTask['REGLAS_VALIDACION'] === 'Ejecutar' && $infoExtra) {
                $idWorkflowEjecutar = $infoExtra['id_workflow'] ?? null;
            }
        }

        // Formatear respuesta
        $response = [
            'NOMBRE_TAREA' => $arrTask['NOMBRE_TAREA'],
            'DESCRIPCION' => $arrTask['DESCRIPCION'],
            'SECUENCIA' => $arrTask['SECUENCIA'],
            'REQUIERE_VALIDACION' => $arrTask['REQUIERE_VALIDACION'],
            'USUARIOS_NOTIFICAR' => json_decode($arrTask['USUARIOS_NOTIFICAR'], true) ?: [],
            'USUARIO_VALIDADOR' => json_decode($arrTask['USUARIO_VALIDADOR'], true) ?: [],
            'REGLAS_VALIDACION' => $arrTask['REGLAS_VALIDACION'],
            'MODULO' => [
                'id' => $arrTask['ID_MODULO'] ? $this->encController->encrypt($arrTask['ID_MODULO']) : null,
                'nombre' => $arrTask['NOMBRE_MODULO']
            ],
            'SUBMODULO' => $arrTask['ID_SUBMODULO'] ? [
                'id' => $this->encController->encrypt($arrTask['ID_SUBMODULO']),
                'nombre' => $arrTask['NOMBRE_SUBMODULO']
            ] : null,
            'FUNCION' => [
                'id' => $arrTask['ID_FUNCION'],
                'nombre' => $arrTask['NOMBRE_FUNCION']
            ],
            'ID_WORKFLOW_EJECUTAR' => $idWorkflowEjecutar,
            'INTERVALO' => $intervalo,
            'UNIDAD' => $unidad
        ];

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $response);
    }

    public function updateWorkflowTask(Request $request, $idTask)
    {

        Log::info($request);
        $validator = Validator::make($request->all(), [
            'NOMBRE_TAREA' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'SECUENCIA' => 'required|integer',
            'REQUIERE_VALIDACION' => 'nullable|boolean',
            'USUARIOS_NOTIFICAR' => 'array',
            'USUARIO_VALIDADOR' => 'array',
            'REGLAS_VALIDACION' => 'string|in:Esperar,Ejecutar,NA',
            'ID_FUNCION' => 'nullable|string',
            'ID_MODULO' => 'nullable|string',
            'ID_SUBMODULO' => 'nullable|string',
            'ID_WORKFLOW_EJECUTAR' => 'nullable|integer',
            'INTERVALO' => 'nullable|integer',
            'UNIDAD' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }



        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        $decryptMod = $this->encController->decrypt($requestData['ID_MODULO']);
        if (!$decryptMod) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ID_MODULO no fue desencriptada correctamente", [], 400);
        }

        $decryptSubMod = null;
        if (!empty($requestData['ID_SUBMODULO'])) {
            $decryptSubMod = $this->encController->decrypt($requestData['ID_SUBMODULO']);
            if (!$decryptSubMod) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ID_SUBMODULO no fue desencriptada correctamente", [], 400);
            }
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        $informacionExtra = $this->processExtraInfo(
            $requestData['REGLAS_VALIDACION'],
            $requestData
        );

        try {
            $validateUpdate = DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'TAWO_NOTA' => $requestData['NOMBRE_TAREA'],
                    'TAWO_DESC' => $requestData['DESCRIPCION'],
                    'TAWO_SECU' => $requestData['SECUENCIA'],
                    'TAWO_RQVA' => $requestData['REQUIERE_VALIDACION'],
                    'TAWO_USAN' => json_encode($requestData['USUARIOS_NOTIFICAR']),
                    'TAWO_USAV' => json_encode($requestData['USUARIO_VALIDADOR']),
                    'TAWO_REVA' => $requestData['REGLAS_VALIDACION'],
                    'TAWO_IDFU' => $requestData['ID_FUNCION'],
                    'TAWO_IDMO' => $decryptMod,
                    'TAWO_IDSM' => $decryptSubMod,
                    'TAWO_INEX' => $informacionExtra,
                    'TAWO_USMO' => $user,
                    'TAWO_FEMO' => $currentDate,
                    'TAWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al actualizar la tarea.", $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo actualizar la tarea.", [], 404);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Tarea actualizada exitosamente");
    }

    public function deleteTask(Request $request, $idTask)
    {
        $validator = Validator::make($request->all(), [
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        $idTask = $this->encController->decrypt($idTask);
        if (is_null($idTask)) {
            return $this->responseController->makeResponse(true, 'El identificador de la tarea no está encriptado correctamente.', [], 400);
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        try {
            $task = (array) DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first(['TAWO_IDWO', 'TAWO_SECU']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener la tarea.", $th->getMessage(), 500);
        }

        if (empty($task)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "La tarea no existe.", [], 404);
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        try {
            DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->delete();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al eliminar la tarea.", $th->getMessage(), 500);
        }

        try {
            DB::table('S002V01TTAWO')
                ->where('TAWO_IDWO', '=', $task['TAWO_IDWO'])
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_SECU', '>', $task['TAWO_SECU'])
                ->decrement('TAWO_SECU');
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al reordenar las secuencias.", $th->getMessage(), 500);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Tarea eliminada exitosamente");
    }

    public function updateTaskConfiguration(Request $request, $idTask)
    {
        $validator = Validator::make($request->all(), [
            'REQUIERE_VALIDACION' => 'nullable|boolean',
            'USUARIOS_NOTIFICAR' => 'array',
            'USUARIO_VALIDADOR' => 'array',
            'REGLAS_VALIDACION' => 'string|in:Esperar,Ejecutar,NA',
            'ID_FUNCION' => 'nullable|string',
            'ID_MODULO' => 'nullable|string',
            'ID_SUBMODULO' => 'nullable|string',
            'ID_WORKFLOW_EJECUTAR' => 'nullable|integer',
            'INTERVALO' => 'nullable|integer',
            'UNIDAD' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        Log::info($request);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $idTask = $this->encController->decrypt($idTask);
        if (is_null($idTask)) {
            return $this->responseController->makeResponse(true, 'El identificador de la tarea no se encuentra encriptado correctamente.', [], 401);
        }

        $idmod = $this->encController->decrypt($request['ID_MODULO']);
        if (is_null($idmod)) {
            return $this->responseController->makeResponse(true, 'El identificador deL modulo no se encuentra encriptado correctamente.', [], 401);
        }

        $user = $arrResponseCheckUser['response'];

        $decryptSubmod = null;
        if (!empty($requestData['ID_SUBMODULO'])) {
            $decryptSubmod = $this->encController->decrypt($requestData['ID_SUBMODULO']);
            if (!$decryptSubmod) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ID_SUBMODULO no fue desencriptada correctamente", [], 400);
            }
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        $informacionExtra = $this->processExtraInfo(
            $requestData['REGLAS_VALIDACION'],
            $requestData
        );

        try {
            $validateUpdate = DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'TAWO_RQVA' => $requestData['REQUIERE_VALIDACION'],
                    'TAWO_USAN' => json_encode($requestData['USUARIOS_NOTIFICAR']),
                    'TAWO_USAV' => json_encode($requestData['USUARIO_VALIDADOR']),
                    'TAWO_REVA' => $requestData['REGLAS_VALIDACION'],
                    'TAWO_IDFU' => $requestData['ID_FUNCION'],
                    'TAWO_IDMO' => $idmod,
                    'TAWO_IDSM' => $decryptSubmod,
                    'TAWO_INEX' => $informacionExtra,
                    'TAWO_USMO' => $user,
                    'TAWO_FEMO' => $currentDate,
                    'TAWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al actualizar la configuración de la tarea.", $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo actualizar la configuración de la tarea.", [], 404);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Configuración de tarea actualizada exitosamente");
    }

    public function getValidateApplications($user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {

            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $idUser = $this->encController->decrypt($user);
        if (is_null($idUser)) {
            return $this->responseController->makeResponse(true, 'El identificador del usuario no se encuentra encriptado correctamente.', [], 401);
        }


        try {
            $results = DB::table('s002v01tsova as s')
                ->join('S002V01TEJTW as e', 's.SOVA_IDET', '=', 'e.EJTW_IDET')
                ->join('S002V01TTAWO as t', 'e.EJTW_IDTA', '=', 't.TAWO_IDTA')
                ->join('S002V01TWORK as w', 't.TAWO_IDWO', '=', 'w.WORK_IDWO')
                ->where('s.SOVA_IDUS', '=', $idUser)
                ->select(
                    's.SOVA_IDET AS ID_APPLICATION',
                    's.SOVA_FEEN AS FECHA_SOLICITUD',
                    's.SOVA_ESTA AS ESTADO_SOLICITUD',
                    't.TAWO_NOTA AS NOMBRE_TAREA',
                    't.TAWO_SECU AS SECUENCIA_TAREA',
                    'w.WORK_NOWO AS NOMBRE_WORKFLOW'
                )
                ->get();

            return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las solicitudes de validación.", $th->getMessage(), 500);
        }
    }

    public function asignStateToApplication(Request $request)
    {
        Log::info($request);
        $validator = Validator::make($request->all(), [
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
            'ID_APPLICATION' => 'required|integer',
            'STATE' => 'required|string|in:Rechazada,Aprobada',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        DB::beginTransaction();

        try {
            // Verificar estado actual
            $currentRecord = DB::table('S002V01TSOVA')
                ->where('SOVA_IDSV', '=', $requestData['ID_APPLICATION'])
                ->first(['SOVA_ESTA']);

            if (!$currentRecord) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "La solicitud no existe.", [], 404);
            }

            if ($currentRecord->SOVA_ESTA !== 'Pendiente') {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No es posible cambiar el estado de la solicitud, el estado actual es: " . $currentRecord->SOVA_ESTA, [], 400);
            }

            $validateUpdate = DB::table('S002V01TSOVA')
                ->where('SOVA_IDSV', '=', $requestData['ID_APPLICATION'])
                ->where('SOVA_ESTA', '=', 'Pendiente')
                ->update(['SOVA_ESTA' => $requestData['STATE'], 'SOVA_FERE' => now()]);

            if (!$validateUpdate) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se pudo actualizar el estado de la solicitud.", [], 404);
            }

            DB::commit();
            return $this->responseController->makeResponse(false, "ÉXITO: Estado actualizado exitosamente");
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al actualizar el estado.", $th->getMessage(), 500);
        }
    }

    //Submodulo de auditoria: Busqueda de flujos de trabajo y solicitudes de validacion
    public function getProcessWorkflow($user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrProcessWorkflow = DB::table('S002V01TPRWO')
                ->where('PRWO_NULI', '=', $line)
                ->get([
                    'PRWO_IDPR AS ID_PROCESO',
                    'PRWO_IDMO AS ID_MODULO',
                    'PRWO_NOPR AS NOMBRE_PROCESO',
                    'PRWO_ESTA AS ESTADO',
                ]);
            $arrProcessWorkflow = json_decode(json_encode($arrProcessWorkflow), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el proceso del flujo de trabajo.", $th->getMessage(), 500);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrProcessWorkflow);
    }

    public function getExecuteWorkflow($user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        try {
            $arrExecuteWorkflow = DB::table('S002V01TEJWO')
                ->where('EJWO_NULI', '=', $line)
                ->where('WORK_NULI', '=', $line)
                ->join('S002V01TWORK', 'WORK_IDWO', '=', 'EJWO_IDWO')
                ->get([
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                    DB::raw('CONCAT(WORK_NOWO, " (", WORK_IDWO, ")") AS NOMBRE_WORKFLOW'),
                    'WORK_AUTO AS AUTOMATICO',
                    'EJWO_ESTA AS ESTADO',
                    'EJWO_USRE AS USUARIO_REGISTRA',
                    'EJWO_FERE AS FECHA_REGISTRA',
                    'EJWO_USMO AS USUARIO_MODIFICA',
                    'EJWO_FEMO AS FECHA_MODIFICA',
                ]);
            $arrExecuteWorkflow = json_decode(json_encode($arrExecuteWorkflow), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las ejecuciones de los flujos de trabajo.", $th->getMessage(), 500);
        }

        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate($arrExecuteWorkflow, $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrExecuteWorkflow = $responseCheckLatestUpdate['response'];

        $arrDataExecuteWorkflow = array();
        foreach ($arrExecuteWorkflow as $key => $executeWorkflow) {
            try {
                $arrExecuteTask = DB::table('S002V01TEJTW')
                    ->where('EJTW_IDEW', '=', $executeWorkflow['ID_EJECUCION_WORKFLOW'])
                    ->where('EJTW_NULI', '=', $line)
                    ->get([
                        'EJTW_IDET AS ID_EJECUCION_TAREA',
                        'EJTW_IDTA AS ID_TAREA',
                        'EJTW_ESTA AS ESTADO',
                    ]);
                $arrExecuteTask = json_decode(json_encode($arrExecuteTask), true);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas en ejecución", $th->getMessage(), 500);
            }

            $executeWorkflow['AUTOMATICO'] = $executeWorkflow['AUTOMATICO'] == 1 ? 'Si' : 'No';

            $existsUser = false;

            $quantityProcesses = 0;
            $quantityCompleted = 0;
            foreach ($arrExecuteTask as $executeTask) {
                if ($executeTask['ESTADO'] === 'Aceptado') {
                    $quantityCompleted++;
                }
                $quantityProcesses++;

                try {
                    $validateExists = DB::table('S002V01TEJNO')
                        ->where('EJNO_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                        ->where('EJNO_NULI', '=', $line)
                        ->where('EJNO_USNO', '=', $user)
                        ->exists();
                } catch (\Throwable $th) {
                    return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los usuarios de notificación.", $th->getMessage(), 500);
                }

                if ($validateExists) {
                    $existsUser = true;
                }
            }


            $progress = ($quantityCompleted * 100) / $quantityProcesses;
            $executeWorkflow['PROGRESO'] = $progress;

            if ($existsUser) {
                $arrDataExecuteWorkflow[] = $executeWorkflow;
            }
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrDataExecuteWorkflow);
    }
    public function getExecuteTask($idExecute, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $idExecute = $this->encController->decrypt($idExecute);
        if ($idExecute === null) {
            return $this->responseController->makeResponse(true, "La ejecución no está desencriptado correctamente.", [], 500);
        }

        try {
            $validateExists = DB::table('S002V01TEJWO')
                ->where('EJWO_IDEW', '=', $idExecute)
                ->where('EJWO_NULI', '=', $line)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al verificar si la ejecución existe.", $th->getMessage(), 500);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, "La ejecución no existe.", [], 500);
        }

        try {
            $arrExecute = DB::table('S002V01TEJTW')
                ->where('EJTW_IDEW', '=', $idExecute)
                ->where('EJTW_NULI', '=', $line)
                ->where('TAWO_NULI', '=', $line)
                ->where('PRWO_NULI', '=', $line)
                ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                ->join('S002V01TWORK', 'WORK_IDWO', '=', 'TAWO_IDWO')
                ->get([
                    'EJTW_IDEW AS ID_EJECUCION_WORKFLOW',
                    'EJTW_IDET AS ID_EJECUCION_TAREA',
                    DB::raw('CONCAT(TAWO_NOTA, " (", TAWO_IDTA, ")") AS NOMBRE_TAREA'),
                    DB::raw('CONCAT(PRWO_NOPR, " (", PRWO_IDPR, ")") AS NOMBRE_PROCESO'),
                    DB::raw('CONCAT(WORK_NOWO, " (", WORK_IDWO, ")") AS NOMBRE_WORKFLOW'),
                    'EJTW_INFO AS INFORMACION_FORMULARIO',
                    'EJTW_INRE AS INFORMACION_REGISTRO',
                    'EJTW_ESTA AS ESTADO',
                    'EJTW_USRE AS USUARIO_REGISTRA',
                    'EJTW_FERE AS FECHA_REGISTRA',
                    'EJTW_USMO AS USUARIO_MODIFICA',
                    'EJTW_FEMO AS FECHA_MODIFICA',
                ]);
            $arrExecute = json_decode(json_encode($arrExecute), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las ejecuciones.", $th->getMessage(), 500);
        }

        foreach ($arrExecute as $keyExecute => $execute) {
            try {
                $notificate = (array) DB::table('S002V01TEJNO')
                    ->where('EJNO_IDET', '=', $execute['ID_EJECUCION_TAREA'])
                    ->where('EJNO_NULI', '=', $line)
                    ->where('EJNO_TINO', '=', 'V')
                    ->where('EJNO_ESTA', '=', 'Notificado')
                    ->orderBy('EJNO_SECU', 'ASC')
                    ->join('S002V01TUSUA', 'USUA_IDUS', '=', 'EJNO_USNO')
                    ->first([
                        DB::raw('CONCAT(USUA_NOMB, " ", USUA_APPA, IF(ISNULL(USUA_APMA), "", CONCAT(" ", USUA_APMA)), " (", USUA_IDUS, ")") AS USUARIO_RESPONSABLE'),
                        'EJNO_ESTA AS ESTADO_NOTIFICACION',
                    ]);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las notificaciones de las tareas de ejecución.", $th->getMessage(), 500);
            }

            if (!empty($notificate)) {
                $execute['USUARIO_RESPONSABLE'] = $notificate['USUARIO_RESPONSABLE'];
            } else if ($execute['ESTADO'] == 'Aceptado') {
                $execute['USUARIO_RESPONSABLE'] = 'Asignación terminada';
            } else {
                $execute['USUARIO_RESPONSABLE'] = 'Sin asignar';
            }

            try {
                $arrNotificate = DB::table('S002V01TEJNO')
                    ->where('EJNO_IDET', '=', $execute['ID_EJECUCION_TAREA'])
                    ->where('EJNO_TINO', '=', 'V')
                    ->where('EJNO_NULI', '=', $line)
                    ->get([
                        'EJNO_ESTA AS ESTADO_NOTIFICACION'
                    ]);
                $arrNotificate = json_decode(json_encode($arrNotificate), true);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las notificaciones de las tareas de ejecución.", $th->getMessage(), 500);
            }

            if (!empty($arrNotificate)) {
                $quantityProcesses = 0;
                $quantityCompleted = 0;
                foreach ($arrNotificate as $notificate) {
                    if ($notificate['ESTADO_NOTIFICACION'] === 'Aceptado') {
                        $quantityCompleted++;
                    }
                    if ($notificate['ESTADO_NOTIFICACION'] !== 'Obsoleto') {
                        $quantityProcesses++;
                    }
                }

                $progress = ($quantityCompleted * 100) / $quantityProcesses;
                $execute['PROGRESO'] = $progress;
            } else {
                $execute['PROGRESO'] = 0;
            }
            $arrExecute[$keyExecute] = $execute;
        }


        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate($arrExecute, $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrExecute = $responseCheckLatestUpdate['response'];

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrExecute);
    }
    public function updateRequestWorkflow(Request $request, $idExecuteTask)
    {
        $validator = Validator::make($request->all(), [
            'ESTADO' => 'required|string|in:Aceptado,Rechazado',
            'MENSAJE_RECHAZO' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        // Se desencripta el identificador de la ejecución de la tarea
        $idExecute = $this->encController->decrypt($idExecuteTask);
        if (is_null($idExecute)) {
            return $this->responseController->makeResponse(true, "No se pudo desencriptar el proceso de ejecución.", [], 500);
        }

        // Se recupera el identificador del usuario
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        // Se valida que el usuario sea para la validación
        try {
            $validate = DB::table('S002V01TEJNO')
                ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJNO_USNO', '=', $user)
                ->where('EJNO_TINO', '=', 'V')
                ->where('EJNO_ESTA', '=', 'Notificado')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar la validación del usuario', $th->getMessage(), 500);
        }
        if (!$validate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El usuario no está autorizado para modificar el estado de la solicitud.', [], 500);
        }

        // Se obtiene la información del workflow
        try {
            $arrExecute = (array) DB::table('S002V01TEJTW')
                ->where('EJTW_IDET', '=', $idExecute)
                ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                ->join('S002V01TEJWO', 'EJWO_IDEW', '=', 'EJTW_IDEW')
                ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                ->first([
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                    'EJWO_IDWO AS ID_WORKFLOW',
                    'EJTW_IDTA AS ID_TAREA',
                    'EJTW_INFO AS INFORMACION_FORMULARIO',
                    'EJTW_INRE AS INFORMACION_REGISTRO',
                    'EJTW_ESTA AS ESTADO',
                    'TAWO_SECU AS SECUENCIA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener los datos del proceso de ejecución.', $th->getMessage(), 500);
        }
        if (empty($arrExecute)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, '', [], 500);
        }

        // Se obtiene la información del proceso
        try {
            $procesoWorkflow = (array) DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $arrExecute['ID_TAREA'])
                ->join('S002V01TPRWO', 'TAWO_IDPR', '=', 'PRWO_IDPR')
                ->first([
                    'PRWO_IDPR AS ID_PROCESO',
                    'PRWO_IDMO AS ID_MODELO',
                    'PRWO_NOPR AS NOMBRE_PROCESO',
                    'PRWO_FVMR AS FORMATO_VALIDACION',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener los datos del proceso del flujo de trabajo.', $th->getMessage(), 500);
        }
        if (empty($procesoWorkflow)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No se encontró el proceso del flujo de trabajo.', [], 500);
        }

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        if ($requestData['ESTADO'] === 'Aceptado') {

            try {
                $validateUdpdate = DB::table('S002V01TEJNO')
                    ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('EJNO_USNO', '=', $user)
                    ->where('EJNO_TINO', '=', 'V')
                    ->where('EJNO_ESTA', '=', 'Notificado')
                    ->where('EJNO_IDET', '=', $idExecute)
                    ->update([
                        'EJNO_ESTA' => 'Aceptado',
                        'EJNO_USMO' => $user,
                        'EJNO_FEMO' => $currentDate,
                        'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar el estado de la notificación. 1', $th->getMessage(), 500);
            }
            if (!$validateUdpdate) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo modificar el estado de la notificación.', [], 500);
            }

            try {
                $arrNextNotificate = (array) DB::table('S002V01TEJNO')
                    ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('EJNO_TINO', '=', 'V')
                    ->where('EJNO_ESTA', '=', 'En espera')
                    ->where('EJNO_IDET', '=', $idExecute)
                    ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('PRWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->join('S002V01TEJTW', 'EJTW_IDET', '=', 'EJNO_IDET')
                    ->join('S002V01TEJWO', 'EJWO_IDEW', '=', 'EJTW_IDEW')
                    ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                    ->join('S002V01TPRWO', 'TAWO_IDPR', '=', 'PRWO_IDPR')
                    ->orderBy('EJNO_SECU', 'ASC')
                    ->first([
                        'EJNO_IDEN AS ID_EJECUCION_NOTIFICACION',
                        'EJNO_IDET AS ID_EJECUCION_TAREA',
                        'EJNO_USNO AS USUARIO_NOTIFICACION',
                        'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                        'TAWO_IDTA AS ID_TAREA',
                        'TAWO_NOTA AS NOMBRE_TAREA',
                        'PRWO_IDPR AS ID_PROCESO',
                        'PRWO_NOPR AS NOMBRE_PROCESO',
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener el siguiente usuario para validación.', $th->getMessage(), 500);
            }

            if (!empty($arrNextNotificate)) {

                $objExecute = ['ID' => $arrNextNotificate['ID_EJECUCION_WORKFLOW'], 'TYPE' => 'VALIDATE'];
                $strExecuteWorkflow = json_encode($objExecute);
                $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

                $this->notificationsController->emitNotification(
                    'S002V01M03GEPR',
                    'Nuevo flujo de procesos creado',
                    "El usuario $user ha creado un nuevo flujo de trabajo: " . $arrNextNotificate['NOMBRE_PROCESO'] . ". La tarea: " . $arrNextNotificate['NOMBRE_TAREA'] . " requiere de su validación.",
                    [[
                        'BOTON' => 'Ver solicitud',
                        'FUNCION' => 'openModule',
                        'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/" . $encExecuteWorkflow)]),
                    ]],
                    [$arrNextNotificate['USUARIO_NOTIFICACION']],
                    $user,
                    $requestData['NUMERO_LINEA'],
                    $this->socketClient,
                );


                try {
                    $validateUpdate = DB::table('S002V01TEJNO')
                        ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('EJNO_TINO', '=', 'V')
                        ->where('EJNO_ESTA', '=', 'En espera')
                        ->where('EJNO_IDET', '=', $idExecute)
                        ->where('EJNO_IDEN', '=', $arrNextNotificate['ID_EJECUCION_NOTIFICACION'])
                        ->update([
                            'EJNO_ESTA' => 'Notificado',
                            'EJNO_USMO' => $user,
                            'EJNO_FEMO' => $currentDate,
                            'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error registrar la notificación de siguiente usuario.', $th->getMessage(), 500);
                }
                if (!$validateUpdate) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo registrar la siguiente notificación del usuario.', [], 500);
                }
            }
        } else {
            try {
                $validateUpdate = DB::table('S002V01TEJNO')
                    ->where('EJNO_IDET', '=', $idExecute)
                    ->where('EJNO_USNO', '=', $user)
                    ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('EJNO_ESTA', '=', 'Notificado')
                    ->where('EJNO_TINO', '=', 'V')
                    ->update([
                        'EJNO_ESTA' => 'Rechazado',
                        'EJNO_MERE' => $requestData['MENSAJE_RECHAZO'],
                        'EJNO_USMO' => $user,
                        'EJNO_FEMO' => $currentDate,
                        'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar el estado de la notificación. 2', $th->getMessage(), 500);
            }
            if (!$validateUpdate) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo modificar el estado de la notificación.', [], 500);
            }
        }

        try {
            $validateExists = DB::table('S002V01TEJNO')
                ->where('EJNO_IDET', '=', $idExecute)
                ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJNO_TINO', '=', 'V')
                ->where('EJNO_ESTA', '=', 'Notificado')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener el siguiente usuario para validación.', $th->getMessage(), 500);
        }

        $newStateExecute = $requestData['ESTADO'];
        if ($validateExists && $requestData['ESTADO'] === 'Aceptado') {
            $newStateExecute = 'En proceso';
        }

        try {
            $validateUpdate = DB::table('S002V01TEJTW')
                ->where('EJTW_IDET', '=', $idExecute)
                ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'EJTW_ESTA' => $newStateExecute,
                    'EJTW_USMO' => $user,
                    'EJTW_FEMO' => $currentDate,
                    'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al modificar la ejecución.", $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo modificar la ejecución.", [], 500);
        }

        try {
            $validateExists = DB::table('S002V01TEJTW')
                ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJTW_IDEW', '=', $arrExecute['ID_EJECUCION_WORKFLOW'])
                ->where('EJTW_ESTA', '=', 'En espera')
                ->orWhere('EJTW_ESTA', '=', 'En proceso')
                ->orWhere('EJTW_ESTA', '=', 'Notificado')
                ->orWhere('EJTW_ESTA', '=', 'Rechazado')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al verificar si existen tareas pendientes.", $th->getMessage(), 500);
        }
        if (!$validateExists) {
            try {
                $validateUpdate = DB::table('S002V01TEJWO')
                    ->where('EJWO_IDEW', '=', $arrExecute['ID_EJECUCION_WORKFLOW'])
                    ->where('EJWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('EJWO_ESTA', '=', 'En proceso')
                    ->update([
                        'EJWO_ESTA' => 'Terminada',
                        'EJWO_USMO' => $user,
                        'EJWO_FEMO' => $currentDate,
                        'EJWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "Ocurrió un error al modificar el estado del flujo de trabajo de ejecución.", $th->getMessage(), 500);
            }
            if (!$validateUpdate) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se pudo modificar el estado del flujo de trabajo de ejecución.", [], 500);
            }



            $strInfoRegister = $this->encController->decrypt($arrExecute['INFORMACION_REGISTRO']);
            $arrInfoRegister = json_decode($strInfoRegister, true);
            $arrFormatValidator = json_decode($procesoWorkflow['FORMATO_VALIDACION'], true);
            foreach ($arrFormatValidator as $keyFormatValidator => $formatValidator) {

                if (!array_key_exists($formatValidator['TABLA'], $arrInfoRegister)) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'La tabla no existe en la información del proceso.', [], 500);
                }

                $tableName = $formatValidator['TABLA'];
                $arrInfoData = $arrInfoRegister[$tableName];
                foreach ($arrInfoData as $infoRegister) {

                    $arrWhere = array();
                    foreach ($infoRegister as $key => $value) {
                        $arrWhere[] = [
                            $key,
                            '=',
                            $value
                        ];
                    }
                    $arrWhere[] = [$formatValidator['NUMERO_LINEA'], '=',  $requestData['NUMERO_LINEA']];

                    try {
                        $validateUpdate = DB::table($tableName)
                            ->where($arrWhere)
                            ->update([
                                $formatValidator['CAMPO_ESTADO'] => $formatValidator['CAMBIO_ESTADO'],
                                $formatValidator['USUARIO_MODIFICA'] => $user,
                                $formatValidator['FECHA_MODIFICA'] => $currentDate,
                            ]);
                    } catch (\Throwable $th) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar los campos de workflow.', $th->getMessage(), 500);
                    }
                    if (!$validateUpdate) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, 'No se pudo modificar los campos de workflow.', [], 500);
                    }
                }
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Modificación Exitosa");
    }
    public function getHistoryNotificateTask($idExecuteTask, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $idExecuteTask = $this->encController->decrypt($idExecuteTask);
        if (is_null($idExecuteTask)) {
            return $this->responseController->makeResponse(true, 'El identificador no está encriptado correctamente.', [], 401);
        }
        try {
            $arrHistory = DB::table('S002V01TEJNO')
                ->where('EJNO_NULI', '=', $line)
                ->where('EJNO_IDET', '=', $idExecuteTask)
                ->where('EJNO_ESTA', '!=', 'Obsoleto')
                ->join('S002V01TUSUA', 'USUA_IDUS', '=', 'EJNO_USNO')
                ->orderBy('EJNO_SECU', 'ASC')
                ->get([
                    'EJNO_IDEN AS ID_EJECUCION_NOTIFICACION',
                    DB::raw(
                        'CONCAT(USUA_NOMB, " ", USUA_APPA, IF(ISNULL(USUA_APMA), "", CONCAT(" ", USUA_APMA)), " (", USUA_IDUS, ")") AS USUARIO_RESPONSABLE'
                    ),
                    'EJNO_TINO AS TIPO_NOTIFICACION',
                    'EJNO_ESTA AS ESTADO',
                    'EJNO_USRE AS USUARIO_REGISTRA',
                    'EJNO_FERE AS FECHA_REGISTRA',
                    'EJNO_USMO AS USUARIO_MODIFICA',
                    'EJNO_FEMO AS FECHA_MODIFICA',
                ]);
            $arrHistory = json_decode(json_encode($arrHistory), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el historial de las notificaciones.", $th->getMessage(), 500);
        }

        foreach ($arrHistory as $key => $history) {
            if ($history['TIPO_NOTIFICACION'] === 'N') {
                $history['TIPO_NOTIFICACION'] = 'Solo notificación';
            } else if ($history['TIPO_NOTIFICACION'] === 'V') {
                $history['TIPO_NOTIFICACION'] = 'Para validación';
            }

            $arrHistory[$key] = $history;
        }

        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate($arrHistory, $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrHistory = $responseCheckLatestUpdate['response'];

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrHistory);
    }

    public function registerRequestWorkflow(int $idProceso, string $encProcess, string $encRequest, string $user, string $line)
    {
        $arrResponse = array('error' => false, 'msg' => '', 'response' => []);

        // Se obtiene la información del proceso de ejecución con los datos del workflow y de la tarea
        try {
            $processWorkflow = (array) DB::table('S002V01TPRWO')
                ->where('PRWO_IDPR', '=', $idProceso)
                ->where('PRWO_NULI', '=', $line)
                ->where('PRWO_ESTA', '=', 'Asignado')
                ->join('S002V01TTAWO', 'TAWO_IDPR', '=', 'PRWO_IDPR')
                ->join('S002V01TWORK', 'WORK_IDWO', '=', 'TAWO_IDWO')
                ->first([
                    'PRWO_IDMO AS ID_MODULO',
                    'PRWO_NOPR AS NOMBRE_PROCESO',
                    'WORK_IDWO AS ID_WORKFLOW',
                    'WORK_NOWO AS NOMBRE_WORKFLOW',
                    'TAWO_IDTA AS ID_TAREA',
                    'TAWO_NOTA AS NOMBRE_TAREA',
                    'TAWO_SECU AS SECUENCIA',
                    'TAWO_REVA AS REGLA_VALIDACION',
                    'TAWO_OTWO AS ID_OTRO_WORKFLOW',
                ]);
        } catch (\Throwable $th) {
            $arrResponse['error'] = true;
            $arrResponse['msg'] = 'Ocurrió un error al obtener los datos del proceso del flujo de trabajo.';
            $arrResponse['response'] = $th->getMessage();
            return $arrResponse;
        }

        // Se obtiene la fecha actual
        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        // Si no se encontraron datos, entonces se termina el proceso.
        if (empty($processWorkflow)) {
            $arrResponse['error'] = true;
            $arrResponse['msg'] = 'El proceso de la tarea no existe.';
            return $arrResponse;
        }

        //  Si la tarea de ejecución es la primera del workflow, entonces...
        if ($processWorkflow['SECUENCIA'] == 1) {

            // Se registra la ejecución del workflow y se obtiene el identificador
            try {
                $idExecuteWorkflow = DB::table('S002V01TEJWO')->insertGetId([
                    'EJWO_NULI' => $line,
                    'EJWO_IDWO' => $processWorkflow['ID_WORKFLOW'],
                    'EJWO_USRE' => $user,
                    'EJWO_FERE' => $currentDate,
                    'EJWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'Ocurrió un error al registrar la ejecución del flujo de trabajo.';
                $arrResponse['response'] = $th->getMessage();
                return $arrResponse;
            }
            if (!$idExecuteWorkflow) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'No se pudo registrar la ejecución del flujo de trabajo.';
                return $arrResponse;
            }


            // Se hace el registro de la ejecución de la tarea del workflow
            try {
                $idExecuteTask = DB::table('S002V01TEJTW')->insertGetId([
                    'EJTW_NULI' => $line,
                    'EJTW_IDEW' => $idExecuteWorkflow,
                    'EJTW_IDTA' => $processWorkflow['ID_TAREA'],
                    'EJTW_INFO' => $encProcess,
                    'EJTW_INRE' => $encRequest,
                    'EJTW_ESTA' => 'En proceso',
                    'EJTW_USRE' => $user,
                    'EJTW_FERE' => $currentDate,
                    'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'Ocurrió un error al registrar la solicitud.';
                $arrResponse['response'] = $th->getMessage();
                return $arrResponse;
            }
            if (!$idExecuteTask) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'No se pudo registrar la solicitud.';
                return $arrResponse;
            }

            // Se obtienen las otras tareas que se ejecutarán
            try {
                $arrTasks = DB::table('S002V01TTAWO')
                    ->where('TAWO_NULI', '=', $line)
                    ->where('TAWO_IDWO', '=', $processWorkflow['ID_WORKFLOW'])
                    ->where('TAWO_IDTA', '!=', $processWorkflow['ID_TAREA'])
                    ->where('TAWO_ESTA', '=', 'Activo')
                    ->orderBy('TAWO_SECU', 'DESC')
                    ->get([
                        'TAWO_IDTA AS ID_TAREA',
                        'TAWO_OTWO AS OTRO_WORKFLOW',
                        'TAWO_IDPR AS ID_PROCESO',
                        'TAWO_NOTA AS NOMBRE_TAREA',
                        'TAWO_DESC AS DESCRIPCION',
                        'TAWO_REVA AS REGLAS_VALIDACION',
                    ]);
                $arrTasks = json_decode(json_encode($arrTasks), true);
            } catch (\Throwable $th) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'Ocurrió un error al obtener las tareas pendientes.';
                $arrResponse['response'] = $th->getMessage();
                return $arrResponse;
            }


            // Se registran las tareas que continuarán para colocarlas en cola.
            foreach ($arrTasks as $task) {
                try {
                    $validateInsert = DB::table('S002V01TEJTW')->insert([
                        'EJTW_NULI' => $line,
                        'EJTW_IDEW' => $idExecuteWorkflow,
                        'EJTW_IDTA' => $task['ID_TAREA'],
                        'EJTW_ESTA' => 'En espera',
                        'EJTW_USRE' => $user,
                        'EJTW_FERE' => $currentDate,
                        'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    $arrResponse['error'] = true;
                    $arrResponse['msg'] = 'Ocurrió un error al registrar la solicitud para en cola.';
                    $arrResponse['response'] = $th->getMessage();
                    return $arrResponse;
                }
                if (!$validateInsert) {
                    $arrResponse['error'] = true;
                    $arrResponse['msg'] = 'No se pudo registrar la solicitud.';
                    return $arrResponse;
                }
            }
            // Se obtiene el primer usuario para la validación de la tarea
            try {
                $notiValidate = DB::table('S002V01TNTWO')
                    ->where('NTWO_IDTA', '=', $processWorkflow['ID_TAREA'])
                    ->where('NTWO_NULI', '=', $line)
                    ->where('NTWO_TINO', '=', 'V')
                    ->where('NTWO_ESTA', '=', 'Activo')
                    ->orderBy('NTWO_SECU', 'ASC')
                    ->get([
                        'NTWO_IDUS AS ID_USUARIO',
                    ]);
                $notiValidate = json_decode(json_encode($notiValidate), true);
            } catch (\Throwable $th) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'Ocurrió un error al obtener los ajustes de las notificaciones.';
                $arrResponse['response'] = $th->getMessage();
                return $arrResponse;
            }
            if (empty($notiValidate)) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'No existe usuario para validar el flujo de trabajo.';
                return $arrResponse;
            }
            // Se obtiene el identificador del usuario
            $validateUser =  $notiValidate[0]['ID_USUARIO'];

            $arrInfoConnection = array();
            $this->socketClient->emit('get_connections', []);
            if ($packet = $this->socketClient->wait('current_connections')) {
                $data = json_decode($packet->data, true);
                $arrInfoConnection = $data;
            }
            $arrUsersConnected = array();
            foreach ($arrInfoConnection as $users) {
                $data = explode('.', $users);
                $userConnected = $this->encController->decrypt($data[0]);
                $arrUsersConnected[] = $userConnected;
            }

            $additionalComments = '';
            switch ($processWorkflow['REGLA_VALIDACION']) {
                case 'S':
                    if (!in_array($validateUser, $arrUsersConnected)) {
                        $additionalComments = 'Se detectó que el usuario que debe validar la solicitud no se encuentra conectado dentro del sistema, sin embargo, la tarea está configurada para esperar a que el usuario se conecte y valide o rechase la solicitud.';
                        goto continue_notification;
                    }
                    break;
                case 'C':
                    check_connection:
                    if (!in_array($validateUser, $arrUsersConnected)) {
                        array_shift($notiValidate);

                        if (empty($notiValidate)) {
                            $additionalComments = 'Se detectó que el usuario no se encuentra conectado dentro del sistema, sin embargo, al no tener otro usuario adicional para validar la tarea, la ejecución se quedará en espera hasta que el usuario se haya conectado.';
                            goto continue_notification;
                        }

                        $validateUser = $notiValidate[0]['ID_USUARIO'];
                        goto check_connection;
                    }
                    break;
                case 'E':
                    if (is_null($processWorkflow['ID_OTRO_WORKFLOW'])) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'Se activó la regla de validación para activar otro flujo de trabajo en caso de que el usuario no se encuentre conectado, sin embargo, no hay otro flujo de trabajo registrado para ejecutar.';
                        return $arrResponse;
                    }

                    $encUser = $this->encController->encrypt($user);
                    if (is_null($encUser)) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'Ocurrió un error al encriptar el usuario.';
                        return $arrResponse;
                    }

                    $requestWorkflow = [
                        'ID_WORKFLOW' => $processWorkflow['ID_OTRO_WORKFLOW'],
                        'USUARIO' => $encUser,
                        'NUMERO_LINEA' => $line,
                    ];

                    $requestWorkflow = new Request($requestWorkflow);

                    $responseWorkflow = $this->activateManualWorkflow($requestWorkflow);
                    $responseWorkflow = json_decode($responseWorkflow->original, true);

                    if ($responseWorkflow['error']) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = $responseWorkflow['msg'];
                        return $arrResponse;
                    }

                    $additionalComments = "Se detectó que el usuario no se encuentra conectado dentro del sistema, sin embargo, las reglas de validación activaron el flujo de trabajo #{$processWorkflow['ID_OTRO_WORKFLOW']}";
                    break;
            }

            continue_notification:
            // Se obtiene el objeto de ejecución
            $objExecute = ['ID' => $idExecuteWorkflow, 'TYPE' => 'VALIDATE'];
            // Se obtiene la cadena del objeto
            $strExecuteWorkflow = json_encode($objExecute);
            // Se obtiene la la cadena encriptada del objeto
            $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);


            $arrUser = $this->resourcesController->getUser($user, $line);
            if ($arrUser['error']) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = $arrUser['msg'];
                return $arrResponse;
            }
            $nameUser = $arrUser['response'];

            // Se emite la notificación para el usuario
            $this->notificationsController->emitNotification(
                'S002V01M03GEPR',
                'Nuevo flujo de procesos creado',
                "El usuario {$nameUser} ha creado un nuevo flujo de trabajo: {$processWorkflow['NOMBRE_PROCESO']} 
                La tarea: {$processWorkflow['NOMBRE_TAREA']} requiere de su validación. \n {$additionalComments}",
                [[
                    'BOTON' => 'Ver solicitud',
                    'FUNCION' => 'openModule',
                    'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/" . $encExecuteWorkflow)]),
                ]],
                [$validateUser],
                $user,
                $line,
                $this->socketClient,
            );

            // Se obtiene los usuarios que solo son para notificar
            try {
                $arrNotification = DB::table('S002V01TNTWO')
                    ->where('NTWO_IDTA', '=', $processWorkflow['ID_TAREA'])
                    ->where('NTWO_NULI', '=', $line)
                    ->where('NTWO_TINO', '!=', 'O')
                    ->where('NTWO_ESTA', '=', 'Activo')
                    ->get([
                        'NTWO_IDUS AS ID_USUARIO',
                        'NTWO_TINO AS TIPO_NOTIFICACION',
                        'NTWO_SECU AS SECUENCIA',
                    ]);
                // Se obtiene la información como un arreglo
                $arrNotification = json_decode(json_encode($arrNotification), true);
            } catch (\Throwable $th) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = 'Ocurrió un error al obtener los ajustes de las notificaciones.';
                $arrResponse['response'] = $th->getMessage();
                return $arrResponse;
            }

            $arrUserNoti = array_filter($arrNotification, fn($value) => $value['TIPO_NOTIFICACION'] === 'N');
            $arrUserNoti = array_column($arrUserNoti, 'ID_USUARIO');


            // Se obtiene el objeto de ejecución
            $objExecute = ['ID' => $idExecuteWorkflow, 'TYPE' => 'NOTIFICATE'];
            // Se obtiene la cadena del objeto
            $strExecuteWorkflow = json_encode($objExecute);
            // Se obtiene la la cadena encriptada del objeto
            $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);


            $arrUserValidation = $this->resourcesController->getUser($validateUser, $line);
            if ($arrUserValidation['error']) {
                $arrResponse['error'] = true;
                $arrResponse['msg'] = $arrUserValidation['msg'];
                return $arrResponse;
            }
            $nameUserValidation = $arrUserValidation['response'];

            // Se emite la notificación 
            $this->notificationsController->emitNotification(
                'S002V01M03GEPR',
                'Nuevo flujo de procesos creado',
                "El usuario $nameUser ha creado un nuevo flujo de trabajo: " . $processWorkflow['NOMBRE_PROCESO'] . ". 
                La tarea: " . $processWorkflow['NOMBRE_TAREA'] . " le notifica que el proceso se encuentra en validación por el usuario: $nameUserValidation.",
                [[
                    'BOTON' => 'Ver solicitud',
                    'FUNCION' => 'openModule',
                    'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/" . $encExecuteWorkflow)]),
                ]],
                $arrUserNoti,
                $user,
                $line,
                $this->socketClient,
            );

            foreach ($arrNotification as $key => $notification) {
                if ($notification['TIPO_NOTIFICACION'] === 'V' && $notification['SECUENCIA'] === 1) {
                    try {
                        $validateInsert = DB::table('S002V01TEJNO')->insert([
                            'EJNO_NULI' => $line,
                            'EJNO_IDET' => $idExecuteTask,
                            'EJNO_USNO' => $notification['ID_USUARIO'],
                            'EJNO_SECU' => $notification['SECUENCIA'],
                            'EJNO_TINO' => 'V',
                            'EJNO_ESTA' => 'Notificado',
                            'EJNO_USRE' => $user,
                            'EJNO_FERE' => $currentDate,
                            'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                    } catch (\Throwable $th) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'Ocurrió un error al registrar las notificaciones de validación principal.';
                        $arrResponse['response'] = $th->getMessage();
                        return $arrResponse;
                    }
                    if (!$validateInsert) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'No se pudo registrar las notificaciones de validación principal.';
                        return $arrResponse;
                    }
                } else if ($notification['TIPO_NOTIFICACION'] === 'V' && $notification['SECUENCIA'] > 1) {
                    try {
                        $validateInsert = DB::table('S002V01TEJNO')->insert([
                            'EJNO_NULI' => $line,
                            'EJNO_IDET' => $idExecuteTask,
                            'EJNO_USNO' => $notification['ID_USUARIO'],
                            'EJNO_SECU' => $notification['SECUENCIA'],
                            'EJNO_TINO' => 'V',
                            'EJNO_ESTA' => 'En espera',
                            'EJNO_USRE' => $user,
                            'EJNO_FERE' => $currentDate,
                            'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                    } catch (\Throwable $th) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'Ocurrió un error al registrar las notificaciones de validación.';
                        $arrResponse['response'] = $th->getMessage();
                        return $arrResponse;
                    }
                    if (!$validateInsert) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'No se pudo registrar las notificaciones de validación.';
                        return $arrResponse;
                    }
                } else {
                    try {
                        $validateInsert = DB::table('S002V01TEJNO')->insert([
                            'EJNO_NULI' => $line,
                            'EJNO_IDET' => $idExecuteTask,
                            'EJNO_USNO' => $notification['ID_USUARIO'],
                            'EJNO_SECU' => 0,
                            'EJNO_TINO' => 'N',
                            'EJNO_ESTA' => 'Notificado',
                            'EJNO_USRE' => $user,
                            'EJNO_FERE' => $currentDate,
                            'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                    } catch (\Throwable $th) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'Ocurrió un error al registrar las notificaciones.';
                        $arrResponse['response'] = $th->getMessage();
                        return $arrResponse;
                    }
                    if (!$validateInsert) {
                        $arrResponse['error'] = true;
                        $arrResponse['msg'] = 'No se pudo registrar las notificaciones.';
                        return $arrResponse;
                    }
                }
            }
        } else {
        }

        return $arrResponse;
    }

    public function activateManualWorkflow(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'ID_WORKFLOW' => 'required|integer',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();

        try {
            $validateExists = DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al verificar si el workflow existe.", $th->getMessage(), 500);
        }
        if (!$validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "El flujo de trabajo no existe.", [], 500);
        }

        try {
            $arrTasks = DB::table('S002V01TTAWO')
                ->where('TAWO_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->where('TAWO_ESTA', '=', 'Activo')
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('PRWO_ESTA', '=', 'Asignado')
                ->where('PRWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                ->orderBy('TAWO_SECU', 'ASC')
                ->get([
                    'TAWO_IDTA AS ID_TAREA',
                    'TAWO_NOTA AS NOMBRE_TAREA',
                    'TAWO_REVA AS REGLA_VALIDACION',
                    'TAWO_OTWO AS OTRO_WORKFLOW',
                    'PRWO_IDPR AS ID_PROCESO',
                    'PRWO_NOPR AS NOMBRE_PROCESO',
                ]);
            $arrTasks = json_decode(json_encode($arrTasks), true);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas del flujo de trabajo.", $th->getMessage(), 500);
        }
        if (empty($arrTasks)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No hay tareas registradas en el flujo de trabajo.", [], 500);
        }

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        try {
            $idExecuteWorkflow = DB::table('S002V01TEJWO')->insertGetId([
                'EJWO_NULI' => $requestData['NUMERO_LINEA'],
                'EJWO_IDWO' => $requestData['ID_WORKFLOW'],
                'EJWO_ESTA' => 'En proceso',
                'EJWO_USRE' => $user,
                'EJWO_FERE' => $currentDate,
                'EJWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la solicitud del flujo de trabajo.", $th->getMessage(), 500);
        }
        if (!$idExecuteWorkflow) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo registrar la solicitud del flujo de trabajo.", [], 500);
        }

        foreach ($arrTasks as $keyTask => $task) {
            try {
                $idExecuteTask = DB::table('S002V01TEJTW')->insertGetId([
                    'EJTW_NULI' => $requestData['NUMERO_LINEA'],
                    'EJTW_IDEW' => $idExecuteWorkflow,
                    'EJTW_IDTA' => $task['ID_TAREA'],
                    'EJTW_ESTA' => $keyTask === 0 ? 'En proceso' : 'En espera',
                    'EJTW_USRE' => $user,
                    'EJTW_FERE' => $currentDate,
                    'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la solicitud de las tareas.", $th->getMessage(), 500);
            }
            if (!$idExecuteTask) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se pudo registrar la solicitud de las tareas.", [], 500);
            }

            if ($keyTask === 0) {
                try {
                    $arrNotificate = DB::table('S002V01TNTWO')
                        ->where('NTWO_IDTA', '=', $task['ID_TAREA'])
                        ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('NTWO_ESTA', '=', 'Activo')
                        ->orderBy('NTWO_SECU', 'ASC')
                        ->get([
                            'NTWO_IDNO AS ID_NOTIFICACION',
                            'NTWO_IDUS AS ID_USUARIO',
                            'NTWO_TINO AS TIPO_NOTIFICACION',
                        ]);
                    $arrNotificate = json_decode(json_encode($arrNotificate), true);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la solicitud de las tareas.", $th->getMessage(), 500);
                }

                $count = 1;
                $userValidate = null;
                $arrUserNotificate = array();

                foreach ($arrNotificate as $keyNotificate => $notificate) {
                    if ($notificate['TIPO_NOTIFICACION'] === 'N') {
                        try {
                            $validateRegister = DB::table('S002V01TEJNO')->insert([
                                'EJNO_NULI' => $requestData['NUMERO_LINEA'],
                                'EJNO_IDET' => $idExecuteTask,
                                'EJNO_USNO' => $notificate['ID_USUARIO'],
                                'EJNO_SECU' => 0,
                                'EJNO_TINO' => 'N',
                                'EJNO_ESTA' => 'Notificado',
                                'EJNO_USRE' => $user,
                                'EJNO_FERE' => $currentDate,
                                'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                            ]);
                        } catch (\Throwable $th) {
                            DB::rollBack();
                            return $this->responseController->makeResponse(true, "Ocurrió un error al registrar las solicitudes de las notificaciones.", $th->getMessage(), 500);
                        }
                        if (!$validateRegister) {
                            DB::rollBack();
                            return $this->responseController->makeResponse(true, "No se pudo registrar las solicitudes de las notificaciones.", [], 500);
                        }
                        $arrUserNotificate[] = $notificate['ID_USUARIO'];
                    } else if ($notificate['TIPO_NOTIFICACION'] === 'V') {
                        try {
                            $validateRegister = DB::table('S002V01TEJNO')->insert([
                                'EJNO_NULI' => $requestData['NUMERO_LINEA'],
                                'EJNO_IDET' => $idExecuteTask,
                                'EJNO_USNO' => $notificate['ID_USUARIO'],
                                'EJNO_SECU' => $count,
                                'EJNO_TINO' => 'V',
                                'EJNO_ESTA' => $count === 1 ? 'Notificado' : 'En espera',
                                'EJNO_USRE' => $user,
                                'EJNO_FERE' => $currentDate,
                                'EJNO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                            ]);
                        } catch (\Throwable $th) {
                            DB::rollBack();
                            return $this->responseController->makeResponse(true, "Ocurrió un error al registrar las solicitudes de validación.", $th->getMessage(), 500);
                        }
                        if (!$validateRegister) {
                            DB::rollBack();
                            return $this->responseController->makeResponse(true, "No se pudo registrar las solicitudes de las validaciones.", [], 500);
                        }
                        if ($count === 1) {
                            $userValidate = $notificate['ID_USUARIO'];
                        }
                        $count++;
                    }
                }

                if (!empty($arrUserNotificate) && !is_null($userValidate)) {
                    $objExecute = ['ID' => $idExecuteWorkflow, 'TYPE' => 'NOTIFICATE'];
                    $strExecuteWorkflow = json_encode($objExecute);
                    $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

                    $this->notificationsController->emitNotification(
                        'S002V01M03GEPR',
                        'Nuevo flujo de procesos creado',
                        "El usuario $user ha creado un nuevo flujo de trabajo: {$task['NOMBRE_PROCESO']}. 
                        La tarea: " . $task['NOMBRE_TAREA'] . " le notifica que el proceso se encuentra en validación por el usuario: $userValidate.",
                        [[
                            'BOTON' => 'Ver solicitud',
                            'FUNCION' => 'openModule',
                            'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/" . $encExecuteWorkflow)]),
                        ]],
                        $arrUserNotificate,
                        $user,
                        $requestData['NUMERO_LINEA'],
                        $this->socketClient,
                    );
                }

                if (!is_null($userValidate)) {
                    $objExecute = ['ID' => $idExecuteWorkflow, 'TYPE' => 'VALIDATE'];
                    $strExecuteWorkflow = json_encode($objExecute);
                    $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

                    $this->notificationsController->emitNotification(
                        'S002V01M03GEPR',
                        'Nuevo flujo de procesos creado',
                        "El usuario $user ha creado un nuevo flujo de trabajo: " . $task['NOMBRE_PROCESO'] . ". 
                        La tarea: " . $task['NOMBRE_TAREA'] . " requiere de su validación.",
                        [[
                            'BOTON' => 'Ver solicitud',
                            'FUNCION' => 'openModule',
                            'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/" . $encExecuteWorkflow)]),
                        ]],
                        [$userValidate],
                        $user,
                        $requestData['NUMERO_LINEA'],
                        $this->socketClient,
                    );
                }
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }

    public function searchRequestWorkflow(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'WORKFLOW' => 'nullable|integer',
            'EJECUCION_WORKFLOW' => 'nullable|integer',
            'ESTADO_WORKFLOW' => 'nullable|string',
            'TAREA' => 'nullable|integer',
            'EJECUCION_TAREA' => 'nullable|integer',
            'ESTADO_TAREA' => 'nullable|string',
            'PROCESO' => 'nullable|string',
            'FECHA_INICIO' => 'nullable|string',
            'FECHA_FINAL' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }


        DB::beginTransaction();
        $requestData = $request->all();

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        $filterData = array(
            'WORKFLOW' => 'WORK_IDWO',
            'EJECUCION_WORKFLOW' => 'EJWO_IDEW',
            'ESTADO_WORKFLOW' => 'EJWO_ESTA',
            'TAREA' => 'TAWO_IDTA',
            'EJECUCION_TAREA' => 'EJTW_IDET',
            'ESTADO_TAREA' => 'EJTW_ESTA',
            'PROCESO' => 'PRWO_IDPR',
        );

        $dataWhere = array();
        foreach ($requestData as $key => $value) {
            if (
                !is_null($value) &&
                $key !== 'USUARIO' &&
                $key !== 'NUMERO_LINEA' &&
                $key !== 'FECHA_INICIO' &&
                $key !== 'FECHA_FINAL'
            ) {
                $dataWhere[$filterData[$key]] = $value;
            }
        }

        try {
            $arrFilter = DB::table('S002V01TEJWO')
                ->where($dataWhere)
                ->where('EJWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('PRWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->join('S002V01TWORK', 'WORK_IDWO', '=', 'EJWO_IDWO')
                ->join('S002V01TEJTW', 'EJTW_IDEW', '=', 'EJWO_IDEW')
                ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                ->get([
                    DB::raw('CONCAT(WORK_NOWO, " (", WORK_IDWO, ")") AS NOMBRE_WORKFLOW'),
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                    'EJWO_ESTA AS ESTADO_EJECUCION_WORKFLOW',
                    DB::raw('CONCAT(TAWO_NOTA, " (", TAWO_IDTA, ")") AS NOMBRE_TAREA'),
                    'EJTW_IDET AS ID_EJECUCION_TAREA',
                    'EJTW_ESTA AS ESTADO_EJECUCION_TAREA',
                    DB::raw('CONCAT(PRWO_NOPR, " (", PRWO_IDPR, ")") AS NOMBRE_PROCESO'),
                    'EJTW_USRE AS USUARIO_REGISTRA',
                    'EJTW_FERE AS FECHA_REGISTRA',
                    'EJTW_USMO AS USUARIO_MODIFICA',
                    'EJTW_FEMO AS FECHA_MODIFICA',
                ]);
            $arrFilter = json_decode(json_encode($arrFilter), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener los datos de las solicitudes de los flujos de trabajo.', $th->getMessage(), 401);
        }


        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate($arrFilter, $requestData['NUMERO_LINEA']);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrFilter = $responseCheckLatestUpdate['response'];


        $arrDataFilter = array();

        if (!is_null($requestData['FECHA_INICIO']) && !is_null($requestData['FECHA_FINAL'])) {
            foreach ($arrFilter as $key => $filter) {
                $updateDate = $filter['FECHA_MODIFICA'];
                $date = explode(' ', $updateDate)[0];
                $arrDate = explode('-', $date);
                $strFormattDate = $arrDate[2] . '-' . $arrDate[1] . '-' . $arrDate[0];

                $dateFormattDate = new Carbon($strFormattDate);
                $dateStart = new Carbon($requestData['FECHA_INICIO']);
                $dateEnd = new Carbon($requestData['FECHA_FINAL']);

                if ($dateFormattDate->gte($dateStart) && $dateFormattDate->lte($dateEnd)) {
                    $arrDataFilter[] = $filter;
                }
            }
        } else {
            $arrDataFilter = $arrFilter;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $arrDataFilter);
    }
    public function getDetailsExecuteRequest($idExecuteTask, $user, $line)
    {
        $idExecuteTask = $this->encController->decrypt($idExecuteTask);
        if (is_null($idExecuteTask)) {
            return $this->responseController->makeResponse(true, "La ejecución no está encriptado correctamente.", [], 500);
        }

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrExecuteRequest = (array) DB::table('S002V01TEJWO')
                ->where('EJTW_IDET', '=', $idExecuteTask)
                ->where('EJWO_NULI', '=', $line)
                ->where('WORK_NULI', '=', $line)
                ->where('EJTW_NULI', '=', $line)
                ->where('TAWO_NULI', '=', $line)
                ->where('PRWO_NULI', '=', $line)
                ->join('S002V01TWORK', 'WORK_IDWO', '=', 'EJWO_IDWO')
                ->join('S002V01TEJTW', 'EJTW_IDEW', '=', 'EJWO_IDEW')
                ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                ->first([
                    DB::raw('CONCAT(WORK_NOWO, " (", WORK_IDWO, ")") AS NOMBRE_WORKFLOW'),
                    'WORK_DESC AS DESCRIPCION_WORKFLOW',
                    'WORK_AUTO AS AUTOMATICO',
                    'WORK_PRED AS PREDETERMINADO',
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                    'EJWO_ESTA AS ESTADO_EJECUCION_WORKFLOW',
                    DB::raw('CONCAT(TAWO_NOTA, " (", TAWO_IDTA, ")") AS NOMBRE_TAREA'),
                    'TAWO_DESC AS DESCRIPCION_TAREA',
                    'EJTW_IDET AS ID_EJECUCION_TAREA',
                    'EJTW_INFO AS INFORMACION_FORMULARIO',
                    'EJTW_INRE AS INFORMACION_REGISTRO',
                    'EJTW_ESTA AS ESTADO_EJECUCION_TAREA',
                    DB::raw('CONCAT(PRWO_NOPR, " (", PRWO_IDPR, ")") AS NOMBRE_PROCESO'),
                    'EJTW_USRE AS USUARIO_REGISTRA',
                    'EJTW_FERE AS FECHA_REGISTRA',
                    'EJTW_USMO AS USUARIO_MODIFICA',
                    'EJTW_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener los datos de las solicitudes de los flujos de trabajo.', $th->getMessage(), 401);
        }


        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate([$arrExecuteRequest], $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrExecuteRequest = $responseCheckLatestUpdate['response'][0];

        $arrExecuteRequest['AUTOMATICO'] = $arrExecuteRequest['AUTOMATICO'] === 1 ? 'Si' : 'No';
        $arrExecuteRequest['PREDETERMINADO'] = $arrExecuteRequest['PREDETERMINADO'] === 1 ? 'Si' : 'No';
        $arrExecuteRequest['ID_EJECUCION_WORKFLOW'] = '#' . $arrExecuteRequest['ID_EJECUCION_WORKFLOW'];
        $arrExecuteRequest['ID_EJECUCION_TAREA'] = '#' . $arrExecuteRequest['ID_EJECUCION_TAREA'];

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $arrExecuteRequest);
    }


    public function getDetailsNotificate($idNotificate, $user, $line)
    {
        $idNotificate = $this->encController->decrypt($idNotificate);
        if (is_null($idNotificate)) {
            return $this->responseController->makeResponse(true, "La ejecución no está encriptado correctamente.", [], 500);
        }

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrNotificate = (array) DB::table('S002V01TEJNO')
                ->where('EJNO_IDEN', '=', $idNotificate)
                ->where('EJNO_NULI', '=', $line)
                ->join('S002V01TUSUA', 'USUA_IDUS', '=', 'EJNO_USNO')
                ->first([
                    'EJNO_IDEN AS NUMERO_NOTIFICACION',
                    'EJNO_IDET AS ID_EJECUCION_TAREA',
                    'EJNO_USNO AS USUARIO_NOTIFICACION',
                    'EJNO_SECU AS SECUENCIA',
                    'EJNO_TINO AS TIPO_NOTIFICACION',
                    'EJNO_ESTA AS ESTADO',
                    'EJNO_MERE AS MENSAJE_RECHAZO',
                    'EJNO_USRE AS USUARIO_REGISTRA',
                    'EJNO_FERE AS FECHA_REGISTRA',
                    'EJNO_USMO AS USUARIO_MODIFICA',
                    'EJNO_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener los datos de las notificaciones.', $th->getMessage(), 401);
        }

        $responseCheckLatestUpdate = $this->resourcesController->checkLatestUpdate([$arrNotificate], $line);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrNotificate = $responseCheckLatestUpdate['response'][0];

        $arrNotificate['NUMERO_NOTIFICACION'] = '#' . $arrNotificate['NUMERO_NOTIFICACION'];
        $arrNotificate['ID_EJECUCION_TAREA'] = '#' . $arrNotificate['ID_EJECUCION_TAREA'];
        $arrNotificate['TIPO_NOTIFICACION'] = $arrNotificate['TIPO_NOTIFICACION'] === 'V' ? 'Para validación' : 'Para notificar';

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $arrNotificate);
    }

    public function searchNotificationsAndRequests(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'USUARIOS_NOTIFICADOS' => 'nullable|array',
            'TIPO_NOTIFICACION' => 'nullable|string|in:Solicitud,Notificacion',
            'ESTADO' => 'nullable|string',
            'FECHA_INICIO' => 'nullable|date',
            'FECHA_FIN' => 'nullable|date',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        $requestData = $request->all();
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $query = DB::table('S002V01TNOTI as n')
                ->leftJoin('S002V01TSOVA as s', function ($join) {
                    $join->whereRaw('JSON_UNQUOTE(JSON_EXTRACT(s.SOVA_INEX, "$[0].idtask")) = JSON_UNQUOTE(JSON_EXTRACT(n.NOTI_ACCI, "$[*].idtask"))');
                })
                ->leftJoin('S002V01TNOEJ as ne', function ($join) {
                    $join->whereRaw('JSON_UNQUOTE(JSON_EXTRACT(ne.NOWF_INEX, "$[0].idtask")) = JSON_UNQUOTE(JSON_EXTRACT(n.NOTI_ACCI, "$[*].idtask"))');
                })
                ->where('n.NOTI_NULI', '=', $requestData['NUMERO_LINEA']);

            // Filtro por usuarios notificados
            if (!empty($requestData['USUARIOS_NOTIFICADOS'])) {
                $query->where(function ($q) use ($requestData) {
                    foreach ($requestData['USUARIOS_NOTIFICADOS'] as $usuario) {
                        $q->orWhereJsonContains('n.NOTI_AUDI', $usuario)
                            ->orWhere('s.SOVA_IDUS', '=', $usuario)
                            ->orWhereJsonContains('ne.NOWF_USNO', $usuario);
                    }
                });
            }

            // Filtro por tipo de notificación
            if (!empty($requestData['TIPO_NOTIFICACION'])) {
                if ($requestData['TIPO_NOTIFICACION'] === 'Solicitud') {
                    $query->whereNotNull('s.SOVA_IDSV');
                } else {
                    $query->whereNotNull('ne.NOWF_IDNE');
                }
            }

            // Filtro por estado
            if (!empty($requestData['ESTADO'])) {
                $estado = $requestData['ESTADO'];
                $tipoNotificacion = $requestData['TIPO_NOTIFICACION'] ?? null;

                if ($tipoNotificacion === 'Solicitud') {
                    $estadosPermitidos = ['Pendiente', 'Aprobada', 'Rechazada', 'Aprobada por timeout', 'Leido', 'No leido'];
                    if (in_array($estado, $estadosPermitidos)) {
                        if (in_array($estado, ['Leido', 'No leido'])) {
                            $estadoBuscar = $estado === 'Leido' ? 'Leído' : 'No leído';
                            $query->whereRaw('JSON_SEARCH(n.NOTI_ALCA, "one", ?) IS NOT NULL', [$estadoBuscar]);
                        } else {
                            $query->where('s.SOVA_ESTA', '=', $estado === 'Aprobada por timeout' ? 'Validada por timeout' : $estado);
                        }
                    }
                } else {
                    if (in_array($estado, ['Leido', 'No leido'])) {
                        $estadoBuscar = $estado === 'Leido' ? 'Leído' : 'No leído';
                        $query->whereRaw('JSON_SEARCH(n.NOTI_ALCA, "one", ?) IS NOT NULL', [$estadoBuscar]);
                    }
                }
            }

            // Filtro por fechas
            if (!empty($requestData['FECHA_INICIO'])) {
                $query->whereDate('n.NOTI_FEAR', '>=', $requestData['FECHA_INICIO']);
            }
            if (!empty($requestData['FECHA_FIN'])) {
                $query->whereDate('n.NOTI_FEAR', '<=', $requestData['FECHA_FIN']);
            }

            $results = $query->select(
                'n.NOTI_IDMO',
                'n.NOTI_CONT',
                'n.NOTI_AUDI',
                'n.NOTI_ALCA',
                's.SOVA_ESTA',
                DB::raw('CASE WHEN s.SOVA_IDSV IS NOT NULL THEN "Solicitud" ELSE "Notificacion" END as TIPO_NOTIFICACION'),
                'n.NOTI_FEAR as FECHA_CREACION'
            )->orderBy('n.NOTI_FEAR', 'desc')->get();

            // Procesar resultados para agregar campo de usuarios que vieron
            foreach ($results as $result) {
                if (in_array($requestData['ESTADO'] ?? '', ['Leido', 'No leido'])) {
                    $alcance = json_decode($result->NOTI_ALCA, true) ?: [];
                    $usuariosVieron = [];

                    foreach ($alcance as $item) {
                        if (($item['ESTADO'] ?? '') === 'Leído') {
                            $usuario = DB::table('S002V01TUSUA')
                                ->where('USUA_IDUS', $item['USUARIO'])
                                ->first(['USUA_NOMB', 'USUA_IDUS']);
                            if ($usuario) {
                                $usuariosVieron[] = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                            }
                        }
                    }

                    $result->USUARIOS_VIERON = !empty($usuariosVieron) ? 'visto por ' . implode(', ', $usuariosVieron) : 'no visto';
                }
            }

            return $this->responseController->makeResponse(false, "ÉXITO: Búsqueda completada", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error en la búsqueda.", $th->getMessage(), 500);
        }
    }

    public function searchSolicitudes(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'USUARIO_VALIDADOR' => 'nullable|string',
            'ESTADO' => 'nullable|string|in:Pendiente,Aprobada,Rechazada,Validada por timeout',
            'FECHA_INICIO' => 'nullable|date',
            'FECHA_FIN' => 'nullable|date',
            'FECHA_VALIDACION' => 'nullable|date',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(true, "Se encontraron uno o más errores.", $this->responseController->makeErrors($validator->errors()->messages()), 401);
        }

        $requestData = $request->all();
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $query = DB::table('S002V01TNOTI as n')
                ->join('S002V01TSOVA as s', function ($join) {
                    $join->whereRaw('JSON_UNQUOTE(JSON_EXTRACT(s.SOVA_INEX, "$[0].idtask")) = JSON_UNQUOTE(JSON_EXTRACT(n.NOTI_ACCI, "$[3].idtask"))');
                })
                ->where('n.NOTI_NULI', '=', $requestData['NUMERO_LINEA']);

            if (!empty($requestData['USUARIO_VALIDADOR'])) {
                $query->where('s.SOVA_IDUS', '=', $requestData['USUARIO_VALIDADOR']);
            }

            if (!empty($requestData['ESTADO'])) {
                $query->where('s.SOVA_ESTA', '=', $requestData['ESTADO']);
            }

            if (!empty($requestData['FECHA_INICIO'])) {
                $query->whereDate('n.NOTI_FEAR', '>=', $requestData['FECHA_INICIO']);
            }
            if (!empty($requestData['FECHA_FIN'])) {
                $query->whereDate('n.NOTI_FEAR', '<=', $requestData['FECHA_FIN']);
            }
            if (!empty($requestData['FECHA_VALIDACION'])) {
                $query->whereDate('s.SOVA_FERE', '=', $requestData['FECHA_VALIDACION']);
            }

            $results = $query->select(
                'n.NOTI_CONT as MENSAJE',
                'n.NOTI_AUDI as AUDIENCIA',
                'n.NOTI_ALCA as ALCANCE',
                'n.NOTI_FEAR as FECHA_ENVIO',
                's.SOVA_ESTA as ESTADO_SOLICITUD',
                's.SOVA_FERE as FECHA_RESOLUCION'
            )->orderBy('n.NOTI_FEAR', 'desc')->get();

            foreach ($results as $result) {
                // Formatear AUDIENCIA
                $audiencia = json_decode($result->AUDIENCIA, true) ?: [];
                $audienciaFormateada = [];
                foreach ($audiencia as $userId) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $userId)->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) $audienciaFormateada[] = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                }
                $result->AUDIENCIA = implode(', ', $audienciaFormateada);

                // Formatear ALCANCE
                $alcance = json_decode($result->ALCANCE, true) ?: [];
                $leidos = [];
                $noLeidos = [];
                foreach ($alcance as $item) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $item['USUARIO'])->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) {
                        $nombreFormateado = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                        if (($item['ESTADO'] ?? '') === 'Leído') {
                            $leidos[] = $nombreFormateado;
                        } else {
                            $noLeidos[] = $nombreFormateado;
                        }
                    }
                }
                $alcanceFormateado = [];
                if (!empty($leidos)) $alcanceFormateado[] = 'Leído: ' . implode(', ', $leidos);
                if (!empty($noLeidos)) $alcanceFormateado[] = 'No leído: ' . implode(', ', $noLeidos);
                $result->ALCANCE = implode('. ', $alcanceFormateado);
            }

            return $this->responseController->makeResponse(false, "ÉXITO: Búsqueda de solicitudes completada", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error en la búsqueda de solicitudes.", $th->getMessage(), 500);
        }
    }

    public function searchNotificaciones(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'USUARIOS_NOTIFICADOS' => 'nullable|array',
            'ESTADO' => 'nullable|string|in:Leido,No leido',
            'FECHA_INICIO' => 'nullable|date',
            'FECHA_FIN' => 'nullable|date',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(true, "Se encontraron uno o más errores.", $this->responseController->makeErrors($validator->errors()->messages()), 401);
        }

        $requestData = $request->all();
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $query = DB::table('S002V01TNOTI as n')
                ->join('S002V01TNOEJ as ne', function ($join) {
                    $join->whereRaw('JSON_UNQUOTE(JSON_EXTRACT(ne.NOWF_INEX, "$[0].idtask")) = JSON_UNQUOTE(JSON_EXTRACT(n.NOTI_ACCI, "$[0].idtask"))');
                })
                ->where('n.NOTI_NULI', '=', $requestData['NUMERO_LINEA']);

            if (!empty($requestData['USUARIOS_NOTIFICADOS'])) {
                $query->where(function ($q) use ($requestData) {
                    foreach ($requestData['USUARIOS_NOTIFICADOS'] as $usuario) {
                        $q->orWhereJsonContains('ne.NOWF_USNO', $usuario);
                    }
                });
            }

            if (!empty($requestData['ESTADO'])) {
                $estadoBuscar = $requestData['ESTADO'] === 'Leido' ? 'Leído' : 'No leído';
                $query->whereRaw('JSON_SEARCH(n.NOTI_ALCA, "all", ?) IS NOT NULL', [$estadoBuscar]);
            }

            if (!empty($requestData['FECHA_INICIO'])) {
                $query->whereDate('n.NOTI_FEAR', '>=', $requestData['FECHA_INICIO']);
            }
            if (!empty($requestData['FECHA_FIN'])) {
                $query->whereDate('n.NOTI_FEAR', '<=', $requestData['FECHA_FIN']);
            }

            $results = $query->select(
                'n.NOTI_CONT as MENSAJE',
                'n.NOTI_AUDI as AUDIENCIA',
                'n.NOTI_ALCA as ALCANCE',
                'n.NOTI_FEAR as FECHA_ENVIO'
            )->orderBy('n.NOTI_FEAR', 'desc')->get();

            foreach ($results as $result) {
                // Formatear AUDIENCIA
                $audiencia = json_decode($result->AUDIENCIA, true) ?: [];
                $audienciaFormateada = [];
                foreach ($audiencia as $userId) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $userId)->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) $audienciaFormateada[] = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                }
                $result->AUDIENCIA = implode(', ', $audienciaFormateada);

                // Formatear ALCANCE según estado solicitado
                $alcance = json_decode($result->ALCANCE, true) ?: [];
                $leidos = [];
                $noLeidos = [];
                foreach ($alcance as $item) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $item['USUARIO'])->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) {
                        $nombreFormateado = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                        if (($item['ESTADO'] ?? '') === 'Leído') {
                            $leidos[] = $nombreFormateado;
                        } else {
                            $noLeidos[] = $nombreFormateado;
                        }
                    }
                }

                if (!empty($requestData['ESTADO'])) {
                    if ($requestData['ESTADO'] === 'Leido') {
                        $result->ALCANCE = !empty($leidos) ? 'Leído por: ' . implode(', ', $leidos) : 'No leído por nadie';
                    } else {
                        $result->ALCANCE = !empty($noLeidos) ? 'No leído por: ' . implode(', ', $noLeidos) : 'Leído por todos';
                    }
                } else {
                    $alcanceFormateado = [];
                    if (!empty($leidos)) $alcanceFormateado[] = 'Leído por: ' . implode(', ', $leidos);
                    if (!empty($noLeidos)) $alcanceFormateado[] = 'No leído por: ' . implode(', ', $noLeidos);
                    $result->ALCANCE = implode('. ', $alcanceFormateado);
                }
            }

            return $this->responseController->makeResponse(false, "ÉXITO: Búsqueda de notificaciones completada", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error en la búsqueda de notificaciones.", $th->getMessage(), 500);
        }
    }

    public function searchWorkflows(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'PREDETERMINADO' => 'nullable|boolean',
            'ESTADO' => 'nullable|string|in:Borrador,Activo,Eliminado',
            'USUARIO_REGISTRO' => 'nullable|string',
            'EJECUCION_INICIO' => 'nullable|date',
            'EJECUCION_FIN' => 'nullable|date',
            'ESTADO_EJECUCION' => 'nullable|string|in:En proceso,Completada,Interrumpida',
            'REGISTRO_INICIO' => 'nullable|date',
            'REGISTRO_FIN' => 'nullable|date',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(true, "Se encontraron uno o más errores.", $this->responseController->makeErrors($validator->errors()->messages()), 401);
        }

        $requestData = $request->all();
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $query = DB::table('S002V01TWORK as w')
                ->leftJoin('S002V01TEJWO as e', 'w.WORK_IDWO', '=', 'e.EJWO_IDWO')
                ->where('w.WORK_NULI', '=', $requestData['NUMERO_LINEA']);

            // Restricción: Si PREDETERMINADO = true, forzar USUARIO_REGISTRO = SAM
            if (isset($requestData['PREDETERMINADO']) && $requestData['PREDETERMINADO']) {
                $query->where('w.WORK_PRED', '=', 1)
                    ->where('w.WORK_USRE', '=', '0000000001');
            } else {
                if (isset($requestData['PREDETERMINADO']) && !$requestData['PREDETERMINADO']) {
                    $query->where('w.WORK_PRED', '=', 0);
                }
                if (!empty($requestData['USUARIO_REGISTRO'])) {
                    $query->where('w.WORK_USRE', '=', $requestData['USUARIO_REGISTRO']);
                }
            }

            if (!empty($requestData['ESTADO'])) {
                $query->where('w.WORK_ESTA', '=', $requestData['ESTADO']);
            }

            // Restricción: Si ESTADO = Borrador, excluir workflows con ejecuciones
            if (!empty($requestData['EJECUCION_INICIO']) || !empty($requestData['EJECUCION_FIN']) || !empty($requestData['ESTADO_EJECUCION'])) {
                $query->where('w.WORK_ESTA', '!=', 'Borrador');
            }

            if (!empty($requestData['EJECUCION_INICIO'])) {
                $query->whereDate('e.EJWO_FERE', '>=', $requestData['EJECUCION_INICIO']);
            }
            if (!empty($requestData['EJECUCION_FIN'])) {
                $query->whereDate('e.EJWO_FERE', '<=', $requestData['EJECUCION_FIN']);
            }
            if (!empty($requestData['ESTADO_EJECUCION'])) {
                $query->where('e.EJWO_ESTA', '=', $requestData['ESTADO_EJECUCION']);
            }

            if (!empty($requestData['REGISTRO_INICIO'])) {
                $query->whereDate('w.WORK_FERE', '>=', $requestData['REGISTRO_INICIO']);
            }
            if (!empty($requestData['REGISTRO_FIN'])) {
                $query->whereDate('w.WORK_FERE', '<=', $requestData['REGISTRO_FIN']);
            }

            $results = $query->select(
                'w.WORK_IDWO as ID_WORKFLOW',
                'w.WORK_NOWO as NOMBRE_WORKFLOW',
                'w.WORK_DESC as DESC_WORKFLOW',
                'w.WORK_ESTA as ESTADO_WORKFLOW',
                'w.WORK_USRE as USUARIO_REGISTRO',
                'w.WORK_FERE as FECHA_REGISTRO',
                DB::raw('COUNT(e.EJWO_IDEW) as EJECUCIONES'),
                DB::raw('MAX(e.EJWO_FERE) as ULTIMA_EJECUCION')
            )
                ->groupBy('w.WORK_IDWO', 'w.WORK_NOWO', 'w.WORK_DESC', 'w.WORK_ESTA', 'w.WORK_USRE', 'w.WORK_FERE')
                ->orderBy('w.WORK_FERE', 'desc')
                ->get();

            foreach ($results as $result) {
                if (!empty($result->USUARIO_REGISTRO)) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $result->USUARIO_REGISTRO)->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) {
                        $result->USUARIO_REGISTRO = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                    }
                }
            }

            return $this->responseController->makeResponse(false, "ÉXITO: Búsqueda de workflows completada", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error en la búsqueda de workflows.", $th->getMessage(), 500);
        }
    }

    public function getWorkflowExecutionsHistory($idWorkflow, $user, $line)
    {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $results = DB::table('S002V01TWORK as w')
                ->join('S002V01TEJWO as ew', 'w.WORK_IDWO', '=', 'ew.EJWO_IDWO')
                ->join('S002V01TEJTW as et', 'ew.EJWO_IDEW', '=', 'et.EJTW_IDEW')
                ->join('S002V01TTAWO as ta', 'et.EJTW_IDTA', '=', 'ta.TAWO_IDTA')
                ->where('w.WORK_IDWO', '=', $idWorkflow)
                ->where('w.WORK_NULI', '=', $line)
                ->select(
                    'w.WORK_IDWO AS ID_WORKFLOW',
                    'w.WORK_NOWO AS NOMBRE_WORKFLOW',
                    'ew.EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                    'et.EJTW_IDOJ AS OBJETO',
                    'ew.EJWO_ESTA AS ESTADO_WORKFLOW',
                    'ew.EJWO_FERE AS FECHA_INICIO',
                    'ew.EJWO_FEMO AS FECHA_COMPLETADO',
                    'et.EJTW_IDET AS ID_EJECUCION_TAREA',
                    'ta.TAWO_NOTA AS NOMBRE_TAREA',
                    'ta.TAWO_SECU AS SECUENCIA',
                    'et.EJTW_ESTA AS ESTADO_TAREA',
                    'et.EJTW_USAT AS USUARIO',
                    'et.EJTW_FERE AS FECHA_EJECUCION'
                )
                ->orderBy('ew.EJWO_FERE', 'desc')
                ->orderBy('ta.TAWO_SECU', 'asc')
                ->get();

            foreach ($results as $result) {
                if (!empty($result->USUARIO)) {
                    $usuario = DB::table('S002V01TUSUA')->where('USUA_IDUS', $result->USUARIO)->first(['USUA_NOMB', 'USUA_IDUS']);
                    if ($usuario) {
                        $result->USUARIO = $usuario->USUA_NOMB . ' (' . $usuario->USUA_IDUS . ')';
                    }
                }
            }

            return $this->responseController->makeResponse(false, "ÉXITO: Historial de ejecuciones obtenido", $results);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener el historial de ejecuciones.", $th->getMessage(), 500);
        }
    }

    /**
     * Procesa la información extra según las reglas de validación Función privada en uso
     */
    private function processExtraInfo($reglasValidacion, $requestData)
    {
        switch ($reglasValidacion) {
            case 'Ejecutar':
                return !empty($requestData['ID_WORKFLOW_EJECUTAR'])
                    ? json_encode(['id_workflow' => $requestData['ID_WORKFLOW_EJECUTAR']])
                    : null;

            case 'Esperar':
                $intervalo = $requestData['INTERVALO'] ?? 5;
                $unidad = $requestData['UNIDAD'] ?? 'seg';
                return json_encode(['intervalo' => $intervalo, 'unidad' => $unidad]);

            default:
                return null;
        }
    }
}