<?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;

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('/');
    }

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

        try {
            $arrWorkflows = DB::table('S002V01TWORK')->select([
                'WORK_IDWO AS ID_WORKFLOW',
                'WORK_NOWO AS NOMBRE_WORKFLOW',
                'WORK_DESC AS DESCRIPCION',
                'WORK_MODU AS MODULO_WORKFLOW',
                'MODU_NOMO AS NOMBRE_MODULO',
                'WORK_AUTO AS AUTOMATICO',
                'WORK_PRED AS PREDEFINIDO',
                'WORK_ESTA AS ESTADO',
                'WORK_USRE AS USUARIO_REGISTRA',
                'WORK_FERE AS FECHA_REGISTRA',
                'WORK_USMO AS USUARIO_MODIFICA',
                'WORK_FEMO AS FECHA_MODIFICA',
            ])->where('WORK_NULI', '=', $line)
            ->join('S002V01TMODU', 'MODU_IDMO', '=', 'WORK_MODU')->get()->all();
            $arrWorkflows = json_decode(json_encode($arrWorkflows), true);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los flujos de trabajo.", $th->getMessage(), 500);
        }

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

        foreach ($arrWorkflows as $key => $workflow) {
            
            if ($workflow['AUTOMATICO'] === 1) {
                $workflow['AUTOMATICO'] = 'Si';
            } else {
                $workflow['AUTOMATICO'] = 'No';
            }
            
            if ($workflow['PREDEFINIDO'] === 1) {
                $workflow['PREDEFINIDO'] = 'Si';
            } else {
                $workflow['PREDEFINIDO'] = 'No';
            }

            $arrWorkflows[$key] = $workflow;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrWorkflows);
    }
    public function getWorkflowById($idWorkflow, $user, $line) {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            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 {
            $arrWorkflow = (array) DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $line)
                ->where('WORK_ESTA', '=', 'Activo')
                ->first([
                    'WORK_NOWO AS NOMBRE_WORKFLOW',
                    'WORK_DESC AS DESCRIPCION',
                    'WORK_AUTO AS AUTOMATICO',
                    'WORK_PRED AS PREDEFINIDO',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            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", $arrWorkflow);
    }
    public function getWorkflowActives($user, $line) {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }

        try {
            $arrWorkflows = DB::table('S002V01TWORK')
                ->where('WORK_NULI', '=', $line)
                ->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) {
            DB::rollBack();
            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 registerWorkflow(Request $request) {
        $validator = Validator::make($request->all(), [
            'NOMBRE_WORKFLOW' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'AUTOMATICO' => 'required|boolean',
            '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, 'ERR_WAREHOUSE_REG001:'.$arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

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

        try {
            $validateInsert = DB::table('S002V01TWORK')->insert([
                'WORK_NULI' => $requestData['NUMERO_LINEA'],
                'WORK_NOWO' => $requestData['NOMBRE_WORKFLOW'],
                'WORK_DESC' => $requestData['DESCRIPCION'],
                'WORK_AUTO' => $requestData['AUTOMATICO'],
                '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 los flujos de trabajo.", $th->getMessage(), 500);
        }

        if (!$validateInsert) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo registrar los flujos de trabajo.", [], 500);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateWorkflow(Request $request, $idWorkflow) {
        $validator = Validator::make($request->all(), [
            'NOMBRE_WORKFLOW' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'AUTOMATICO' => 'required|boolean',
            '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
            );
        }

        try {
            $idWorkflow = $this->encController->decrypt($idWorkflow);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el ID del flujo de trabajo.', $th->getMessage(), 500);
        }

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

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

        try {
            $workflow = (array) DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_ESTA', '=', 'Activo')
                ->first([
                    'WORK_IDWO AS ID_WORKFLOW',
                    'WORK_NOWO AS NOMBRE_WORKFLOW',
                    'WORK_DESC AS DESCRIPCION',
                    'WORK_AUTO AS AUTOMATICO',
                    'WORK_PRED AS PREDEFINIDO',
                    'WORK_HICA AS HISTORIAL_CAMBIOS',
                    'WORK_ESTA AS ESTADO',
                    'WORK_USRE AS USUARIO_REGISTRA',
                    'WORK_FERE AS FECHA_REGISTRA',
                    'WORK_USMO AS USUARIO_MODIFICA',
                    'WORK_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información del flujo de trabajo.', $th->getMessage(), 500);
        }
        if (empty($workflow)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El flujo de trabajo no existe.', [], 406);
        }

        $arrHistory = array();
        if (is_null($workflow['HISTORIAL_CAMBIOS'])) {
            unset($workflow['HISTORIAL_CAMBIOS']);
            $arrHistory[] = $workflow;
        } else {
            $arrHistory = json_decode($workflow['HISTORIAL_CAMBIOS']);
            unset($workflow['HISTORIAL_CAMBIOS']);
            $arrHistory[] = $workflow;
        }
        $strHistory = json_encode($arrHistory);

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

        try {
            $validateUpdate = DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_ESTA', '=', 'Activo')
                ->update([
                    'WORK_NOWO' => $requestData['NOMBRE_WORKFLOW'],
                    'WORK_DESC' => $requestData['DESCRIPCION'],
                    'WORK_AUTO' => $requestData['AUTOMATICO'],
                    'WORK_HICA' => $strHistory,
                    '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 modificar el flujo de trabajo.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No se pudo modificar el flujo de trabajo.', [], 500);
        }


        try {
            $arrExecuteWorkflow = DB::table('S002V01TEJWO')
                ->where('EJWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJWO_IDWO', '=', $idWorkflow)
                ->where('EJWO_ESTA', '=', 'En proceso')
                ->get([
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                ]);
            $arrExecuteWorkflow = json_decode(json_encode($arrExecuteWorkflow), true);
            $arrExecuteWorkflow = array_column($arrExecuteWorkflow, 'ID_EJECUCION_WORKFLOW');
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones pendientes.', $th->getMessage(), 406);
        }

        $arrResendNotificate = array();
        foreach ($arrExecuteWorkflow as $executeWorkflow) {
            try {
                $arrExecuteTask = DB::table('S002V01TEJTW')
                    ->where('EJTW_IDEW', '=', $executeWorkflow)
                    ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('TAWO_ESTA', '=', 'Activo')
                    ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('PRWO_ESTA', '=', 'Asignado')
                    ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                    ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                    ->orderBy('TAWO_SECU', 'ASC')
                    ->get([
                        'EJTW_IDET AS ID_EJECUCION_TAREA',
                        'TAWO_SECU AS SECUENCIA',
                        'TAWO_IDWO AS ID_WORKFLOW',
                        'TAWO_IDTA AS ID_TAREA',
                        'PRWO_IDPR AS ID_PROCESO',
                        'PRWO_NOPR AS NOMBRE_PROCESO'
                    ]);
                $arrExecuteTask = json_decode(json_encode($arrExecuteTask), true);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones de las tareas.', $th->getMessage(), 406);
            }

            foreach ($arrExecuteTask as $keyExecuteTask => $executeTask) {

                if ($executeTask['SECUENCIA'] === 1) {
                    
                    $arrUpdate = [
                        'EJTW_ESTA' => 'En proceso',
                        'EJTW_USMO' => $user,
                        'EJTW_FEMO' => $currentDate,
                        'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                    ];
                } else {
                    $arrUpdate = [
                        'EJTW_INFO' => null,
                        'EJTW_INRE' => null,
                        'EJTW_ESTA' => 'En espera',
                        'EJTW_USMO' => $user,
                        'EJTW_FEMO' => $currentDate,
                        'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                    ];
                }

                try {
                    $validateUpdate = DB::table('S002V01TEJTW')
                        ->where('EJTW_IDEW', '=', $executeWorkflow)
                        ->where('EJTW_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                        ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->update($arrUpdate);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar las ejecuciones de las tareas.', $th->getMessage(), 406);
                }
                if (!$validateUpdate) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo modificar las ejecuciones de las tareas.', [], 406);
                }

                try {
                    $validateExists = DB::table('S002V01TEJNO')
                        ->where('EJNO_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                        ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->exists();
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones de las notificaciones.', $th->getMessage(), 406);
                }
                if ($validateExists) {
                    try {
                        $validateUpdate = DB::table('S002V01TEJNO')
                            ->where('EJNO_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                            ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                            ->update([
                                'EJNO_ESTA' => 'Obsoleto',
                                '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 las ejecuciones de las notificaciones.', $th->getMessage(), 406);
                    }
                    if (!$validateUpdate) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, 'No se pudo modificar las ejecuciones de las notificaciones.', [], 406);
                    }
                }

                if ($executeTask['SECUENCIA'] === 1) {
                    $arrResendNotificate[] = [
                        'ID_EJECUCION_WORKFLOW' => $executeWorkflow,
                        'ID_WORKFLOW' => $executeTask['ID_WORKFLOW'],
                        'ID_TAREA' => $executeTask['ID_TAREA'],
                        'ID_EJECUCION_TAREA' => $executeTask['ID_EJECUCION_TAREA'],
                        'ID_PROCESO' => $executeTask['ID_PROCESO'],
                        'NOMBRE_PROCESO' => $executeTask['NOMBRE_PROCESO'],
                    ];
                }
            }

        }
        
        foreach ($arrResendNotificate as $resendNotificate) {
            try {
                $arrNotificate = DB::table('S002V01TNTWO')
                    ->where('NTWO_IDTA', '=', $executeTask['ID_TAREA'])
                    ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('NTWO_ESTA', '=', 'Activo')
                    ->orderBy('NTWO_SECU', 'ASC')
                    ->get([
                        'NTWO_IDUS AS USUARIO_NOTIFICACION',
                        'NTWO_TINO AS TIPO_NOTIFICACION',
                        'NTWO_SECU AS SECUENCIA',
                    ]);
                $arrNotificate = json_decode(json_encode($arrNotificate), true);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las notificaciones.', $th->getMessage(), 406);
            }
            
            $userValidate = null;
            $notifacateUsers = array();
            foreach ($arrNotificate as $notificate) {

                try {
                    $validateRegister = DB::table('S002V01TEJNO')->insert([
                        'EJNO_NULI' => $requestData['NUMERO_LINEA'],
                        'EJNO_IDET' => $resendNotificate['ID_EJECUCION_TAREA'],
                        'EJNO_USNO' => $notificate['USUARIO_NOTIFICACION'],
                        'EJNO_SECU' => $notificate['SECUENCIA'],
                        'EJNO_TINO' => $notificate['TIPO_NOTIFICACION'],
                        'EJNO_ESTA' => $notificate['SECUENCIA'] === 1 || $notificate['TIPO_NOTIFICACION'] === 'N'  ? '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 notificaciones.', $th->getMessage(), 406);
                }
                if (!$validateRegister) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo registrar las notificaciones.', [], 406);
                }
                
                if ($notificate['TIPO_NOTIFICACION'] === 'V' && $notificate['SECUENCIA'] === 1) {
                    $userValidate = $notificate['USUARIO_NOTIFICACION'];
                }

                if ($notificate['TIPO_NOTIFICACION'] === 'N') {
                    $notifacateUsers[] = $notificate['USUARIO_NOTIFICACION'];
                }
            }

            if (is_null($userValidate)) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se encontró el usuario para enviar la notificación para la validación de la ejecución #{$resendNotificate['ID_EJECUCION_TAREA']}.", [], 406);
            }
            
            $objExecute = [ 'ID' => $resendNotificate['ID_EJECUCION_WORKFLOW'], 'TYPE' => 'VALIDATE' ];
            $strExecuteWorkflow = json_encode($objExecute);
            $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

            $this->notificationsController->emitNotification(
                'S002V01M03GEPR',
                'Flujo de trabajo modificado.',
                "El flujo de trabajo #{$resendNotificate['ID_WORKFLOW']} ha sido modificado, por lo cual el proceso se ha reiniciado. Se le pide nuevamente realizar el proceso de validación.",
                [[
                    'BOTON' => 'Ver solicitud',
                    'FUNCION' => 'openModule',
                    'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/".$encExecuteWorkflow)]),
                ]],
                [$userValidate],
                $user,
                $requestData['NUMERO_LINEA'],
                $this->socketClient,
            );

            if (!empty($notifacateUsers)) {
                $objExecute = [ 'ID' => $resendNotificate['ID_EJECUCION_WORKFLOW'], 'TYPE' => 'NOTIFICATE' ];
                $strExecuteWorkflow = json_encode($objExecute);
                $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

                $this->notificationsController->emitNotification(
                    'S002V01M03GEPR',
                    'Flujo de trabajo modificado',
                    "El flujo de trabajo #{$resendNotificate['ID_WORKFLOW']} ha sido modificado, por lo cual el proceso se ha reiniciado.",
                    [[
                        'BOTON' => 'Ver solicitud',
                        'FUNCION' => 'openModule',
                        'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/".$encExecuteWorkflow)]),
                    ]],
                    [$notifacateUsers],
                    $user,
                    $requestData['NUMERO_LINEA'],
                    $this->socketClient,
                );
            }
        }


        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Modificación Exitosa");
    }
    public function deleteWorkflow(Request $request, $idWorkflow) {
        $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
            );
        }

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

        try {
            $idWorkflow = $this->encController->decrypt($idWorkflow);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el nivel.', $th->getMessage(), 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'];

        try {
            $workflow = (array) DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_ESTA', '=', 'Activo')
                ->first([
                    'WORK_IDWO AS ID_WORKFLOW',
                    'WORK_NOWO AS NOMBRE_WORKFLOW',
                    'WORK_DESC AS DESCRIPCION',
                    'WORK_AUTO AS AUTOMATICO',
                    'WORK_PRED AS PREDEFINIDO',
                    'WORK_HICA AS HISTORIAL_CAMBIOS',
                    'WORK_ESTA AS ESTADO',
                    'WORK_USRE AS USUARIO_REGISTRA',
                    'WORK_FERE AS FECHA_REGISTRA',
                    'WORK_USMO AS USUARIO_MODIFICA',
                    'WORK_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información del flujo de trabajo.', $th->getMessage(), 500);
        }
        if (empty($workflow)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El flujo de trabajo no existe.', [], 406);
        }

        try {
            $validateTask = DB::table('S002V01TTAWO')
                ->where('TAWO_IDWO', '=', $idWorkflow)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las tareas relacionadas con el flujo de trabajo.', $th->getMessage(), 500);
        }
        if ($validateTask) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Aún existen tareas relacionadas con el flujo de trabajo que está intentando eliminar.', [], 406);
        }

        $arrHistory = array();
        if (is_null($workflow['HISTORIAL_CAMBIOS'])) {
            unset($workflow['HISTORIAL_CAMBIOS']);
            $arrHistory[] = $workflow;
        } else {
            $arrHistory = json_decode($workflow['HISTORIAL_CAMBIOS']);
            unset($workflow['HISTORIAL_CAMBIOS']);
            $arrHistory[] = $workflow;
        }
        $strHistory = json_encode($arrHistory);

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

        try {
            $validateUpdate = DB::table('S002V01TWORK')
                ->where('WORK_IDWO', '=', $idWorkflow)
                ->where('WORK_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('WORK_ESTA', '=', 'Activo')
                ->update([
                    'WORK_ESTA' => 'Eliminado',
                    'WORK_HICA' => $strHistory,
                    '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 eliminar el flujo de trabajo.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No se pudo eliminar el flujo de trabajo.', [], 500);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Eliminación Exitosa");
    }

    public function restoreWorkflows(Request $request){
        $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
            );
        }

        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'];
        $defaultWorkflowsPath = str_replace('app\\Http\\Controllers', 'storage\\app\\public\\global_resources', __DIR__);
        $defaultWorkflowsFile = $defaultWorkflowsPath . '\\default_workflows.sam';

        if(!file_exists($defaultWorkflowsFile)){
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No fue posible encontrar el archivo 'default_workflows.sam' en el almacenamiento del sistema.", [], 500);
        }

        $defaultWorkflowsStr = file_get_contents($defaultWorkflowsFile);
        $defaultWorkflowsDec = $this->encController->decrypt($defaultWorkflowsStr);
        $defaultWorkflowsArr = json_decode($defaultWorkflowsDec, true);

        foreach($defaultWorkflowsArr as $workflow){
            $idwo = $workflow['workflow-id'];
            $nowo = $workflow['workflow-name'];
            $desc = $workflow['workflow-description'];
            $auto = 1;
            $pred = 0;

            $workflowObj = DB::table('S002V01TWORK')->where([
                ['WORK_IDWO', '=', $idwo],
                ['WORK_NULI', '=', $requestData['NUMERO_LINEA']]
            ])->first();

            $vers = is_null($workflowObj) ? 1 : intval($workflowObj->WORK_VERS) + 1;
            $hicaArr = is_null($workflowObj) ? [] : json_decode($workflowObj->WORK_HICA, true);

            $now = $this->functionsController->now();
            $nowStr = $now->toDateTimeString();
            $hicaArr[] = [
                "date" => $nowStr,
                "vers" => $vers,
                "data" => $workflow,
            ];

            $hica = json_encode($hicaArr);
            if(is_null($workflowObj)){
                DB::table('S002V01TWORK')->insert([
                    "WORK_IDWO" => $idwo,
                    "WORK_NULI" => $requestData['NUMERO_LINEA'],
                    "WORK_NOWO" => $nowo,
                    "WORK_DESC" => $desc,
                    "WORK_AUTO" => $auto,
                    "WORK_PRED" => $pred,
                    "WORK_HICA" => $hica,
                    "WORK_ESTA" => 'Activo',
                    "WORK_VERS" => $vers,
                    "WORK_USRE" => $user,
                    "WORK_FERE" => $nowStr,
                ]);
            }else{
                DB::table('S002V01TWORK')->where([
                    ['WORK_IDWO', '=', $idwo],
                    ['WORK_NULI', '=', $requestData['NUMERO_LINEA']]
                ])->update([
                    "WORK_NOWO" => $nowo,
                    "WORK_DESC" => $desc,
                    "WORK_AUTO" => $auto,
                    "WORK_PRED" => $pred,
                    "WORK_HICA" => $hica,
                    "WORK_ESTA" => 'Activo',
                    "WORK_VERS" => $vers,
                    "WORK_USMO" => $user,
                    "WORK_FEMO" => $nowStr,
                ]);
            }

            DB::table('S002V01TTAWO')->where([
                ['TAWO_NULI', '=', $requestData['NUMERO_LINEA']],
                ['TAWO_IDWO', '=', $idwo]
            ])->update(['TAWO_ESTA' => 'Eliminado']);

            foreach($workflow['tasks'] as $task){
                $nota = $task['task-name'];
                $tdesc = $task['task-description'];
                $secu = $task['task-order'];
                $sies = $task['next-state'];
                $auto = $task['automatic'] ? 1 : 0;
                $usua = json_encode($task['users']);
                $acci = json_encode($task['actions']);

                DB::table('S002V01TTAWO')->insert([
                    'TAWO_NULI' => $requestData['NUMERO_LINEA'],
                    'TAWO_IDWO' => $idwo,
                    'TAWO_NOTA' => $nota,
                    'TAWO_DESC' => $tdesc,
                    'TAWO_SECU' => $secu,
                    'TAWO_SIES' => $sies,
                    'TAWO_AUTO' => $auto,
                    'TAWO_USUA' => $usua,
                    'TAWO_ACCI' => $acci,
                    'TAWO_USRE' => $user,
                    'TAWO_FERE' => $nowStr,
                ]);
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Restauración Exitosa");
    }

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

        try {
            $arrTasks = DB::table('S002V01TTAWO')
                ->where('TAWO_NULI', '=', $line)
                ->get([
                    'TAWO_IDTA AS ID_TAREA',
                    'TAWO_IDWO AS ID_WORKFLOW',
                    'TAWO_IDPR AS ID_PROCESO',
                    'TAWO_NOTA AS NOMBRE_TAREA',
                    'TAWO_DESC AS DESCRIPCION',
                    'TAWO_SECU AS SECUENCIA',
                    'TAWO_ESTA AS ESTADO',
                    'TAWO_USRE AS USUARIO_REGISTRA',
                    'TAWO_FERE AS FECHA_REGISTRA',
                    'TAWO_USMO AS USUARIO_MODIFICA',
                    'TAWO_FEMO AS FECHA_MODIFICA',
                ]);
            $arrTasks = json_decode(json_encode($arrTasks), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los flujos de trabajo.", $th->getMessage(), 500);
        }

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

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrTasks);
    }
    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_SECU AS SECUENCIA'
            ])->where([
                ['TAWO_IDWO', '=', $idWorkflow],
                ['TAWO_ESTA', '=', 'Activo'],
                ['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 = (array) DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $line)
                ->where('TAWO_ESTA', '=', 'Activo')
                ->first([
                    'TAWO_IDWO AS ID_WORKFLOW',
                    'TAWO_IDPR AS ID_PROCESO',
                    'TAWO_NOTA AS NOMBRE_TAREA',
                    'TAWO_OTWO AS ID_OTRO_WORKFLOW',
                    'TAWO_DESC AS DESCRIPCION',
                    'TAWO_REVA AS REGLAS_VALIDACION',
                    'TAWO_SECU AS SECUENCIA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas.", $th->getMessage(), 500);
        }
        
        if (empty($arrTask)) {
            return $this->responseController->makeResponse(true, "La tarea no existe.", [], 500);
        }

        try {
            $arrNotificaciones = DB::table('S002V01TNTWO')
                ->where('NTWO_IDTA', '=', $idTask)
                ->where('NTWO_NULI', '=', $line)
                ->where('NTWO_ESTA', '=', 'Activo')
                ->orderBy('NTWO_SECU', 'ASC')
                ->get([
                    'NTWO_IDUS AS ID_USUARIO',
                    'NTWO_TINO AS TIPO_NOTIFICACION',
                ]);
            $arrNotificaciones = json_decode(json_encode($arrNotificaciones), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener los usuarios con notificaciones.", $th->getMessage(), 500);
        }

        $arrUserValidator = array();
        $arrUserNotification = array();
        foreach ($arrNotificaciones as $key => $value) {
            if ($value['TIPO_NOTIFICACION'] === 'V') {
                $arrUserValidator[] = $value['ID_USUARIO'];
            }
            if ($value['TIPO_NOTIFICACION'] === 'N') {
                $arrUserNotification[] = $value['ID_USUARIO'];
            }
        }
        $arrTask['NOTIFICAR_USUARIOS'] = $arrUserNotification;
        $arrTask['USUARIOS_VALIDACION'] = $arrUserValidator;

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrTask);
    }
    public function registerTask(Request $request) {
        $validator = Validator::make($request->all(), [
            'ID_WORKFLOW' => 'string|required',
            'ID_PROCESO' => 'string|required',
            'NOMBRE_TAREA' => 'string|required',
            'DESCRIPCION' => 'string|required',
            'REGLAS_VALIDACION' => 'string|required',
            'ID_OTRO_WORKFLOW' => 'string|nullable',
            'USUARIO_VALIDACION' => 'array|required',
            'NOTIFICAR_USUARIOS' => 'array|required',
            'USUARIO' => 'string|required',
            '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 {
            $countTask = DB::table('S002V01TTAWO')
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas.", $th->getMessage(), 500);
        }
        $countTask = $countTask + 1;

        try {
            $idTask = DB::table('S002V01TTAWO')->insertGetId([
                'TAWO_NULI' => $requestData['NUMERO_LINEA'],
                'TAWO_IDWO' => $requestData['ID_WORKFLOW'],
                'TAWO_OTWO' => $requestData['ID_OTRO_WORKFLOW'],
                'TAWO_IDPR' => $requestData['ID_PROCESO'],
                'TAWO_NOTA' => $requestData['NOMBRE_TAREA'],
                'TAWO_DESC' => $requestData['DESCRIPCION'],
                'TAWO_REVA' => $requestData['REGLAS_VALIDACION'],
                'TAWO_SECU' => $countTask,
                '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 las tareas.", $th->getMessage(), 500);
        }
        if (is_null($idTask)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo registrar las tareas.", [], 500);
        };

        try {
            $validateUpdate = DB::table('S002V01TPRWO')
                ->where('PRWO_IDPR', '=', $requestData['ID_PROCESO'])
                ->where('PRWO_ESTA', '=', 'Sin asignar')
                ->where('PRWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'PRWO_ESTA' => 'Asignado',
                    'PRWO_USMO' => $user,
                    'PRWO_FEMO' => $currentDate,
                    'PRWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "Ocurrió un error al modificar el proceso del flujo de trabajo.", $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo modificar el proceso del flujo de trabajo.", [], 500);
        };
        
        foreach ($requestData['USUARIO_VALIDACION'] as $keyUser => $userValidator) {
            try {
                $validateInsert = DB::table('S002V01TNTWO')->insert([
                    'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                    'NTWO_IDTA' => $idTask,
                    'NTWO_IDUS' => $userValidator,
                    'NTWO_TINO' => 'V',
                    'NTWO_SECU' => $keyUser + 1,
                    'NTWO_USRE' => $user,
                    'NTWO_FERE' => $currentDate,
                    'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la notificaciones de validación 1.", $th->getMessage(), 500);
            }
            if (!$validateInsert) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se pudo registrar las notificaciones", [], 500);
            }
        }
        
        $count = 1;
        foreach ($requestData['NOTIFICAR_USUARIOS'] as $key => $value) {
            try {
                $validateInsert = DB::table('S002V01TNTWO')->insert([
                    'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                    'NTWO_IDTA' => $idTask,
                    'NTWO_IDUS' => $value,
                    'NTWO_SECU' => $count,
                    'NTWO_TINO' => 'N',
                    'NTWO_USRE' => $user,
                    'NTWO_FERE' => $currentDate,
                    'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "Ocurrió un error las notificaciones", $th->getMessage(), 500);
            }
            $count++;
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateTask(Request $request, $idTask) {
        $validator = Validator::make($request->all(), [
            'ID_WORKFLOW' => 'string|required',
            'ID_PROCESO' => 'string|required',
            'NOMBRE_TAREA' => 'string|required',
            'DESCRIPCION' => 'string|required',
            'REGLAS_VALIDACION' => 'string|required',
            'ID_OTRO_WORKFLOW' => 'string|nullable',
            'USUARIO_VALIDACION' => 'array|required',
            'NOTIFICAR_USUARIOS' => 'array|nullable',
            'USUARIO' => 'string|required',
            '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();

        // Desencripta el usuario y verifica que el usuario exista en la base de datos
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        // Guarda el número del usuario
        $user = $arrResponseCheckUser['response'];

        // Obtiene la información del identificador de la tarea
        $idTask = $this->encController->decrypt($idTask);
        if (is_null($idTask)) {
            return $this->responseController->makeResponse(true, 'La tarea no está encriptado correctamente.', [], 406);
        }

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

        try {
            //Se verifica que el identificador de la tarea exista
            $validateExists = DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si existe la tarea.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'La tarea no existe.', [], 406);
        }

        try {
            // Actualiza la información de la tarea según los datos del formulario obtenido
            $validateUpdate = DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_ESTA', '=', 'Activo')
                ->update([
                    'TAWO_IDWO' => $requestData['ID_WORKFLOW'],
                    'TAWO_OTWO' => $requestData['ID_OTRO_WORKFLOW'],
                    'TAWO_IDPR' => $requestData['ID_PROCESO'],
                    'TAWO_NOTA' => $requestData['NOMBRE_TAREA'],
                    'TAWO_DESC' => $requestData['DESCRIPCION'],
                    'TAWO_REVA' => $requestData['REGLAS_VALIDACION'],
                    '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 registrar las tareas.", $th->getMessage(), 500);
        }
        // Se verifica que la información haya sido actualizada correctamente
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "No se pudo registrar las tareas.", [], 500);
        };
        
        try {
            // Se obtiene la información de las notificaciones para validar de la tarea
            $arrNotfValidate = DB::table('S002V01TNTWO')
                ->where('NTWO_TINO', '=', 'V')
                ->where('NTWO_ESTA', '=', 'Activo')
                ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NTWO_IDTA', '=', $idTask)
                ->get([
                    'NTWO_IDUS AS ID_USUARIO',
                ]);
            // La información es pasada a un arreglo
            $arrNotfValidate = json_decode(json_encode($arrNotfValidate), true);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error un al obtener el usuario de notificación de validación.', $th->getMessage(), 406);
        }
        // Se obtiene únicamente la información del usuario
        $arrNotification = array_column($arrNotfValidate, 'ID_USUARIO');

        // Si no hay información de usuarios para validar, entonces...
        if (empty($arrNotfValidate)) {
            // Variable para colocar la secuencia de los usuarios a validar
            $count = 1;
            foreach ($requestData['USUARIO_VALIDACION'] as $key => $value) {
                try {
                    // Se registran los usuarios en el orden en el que están registrados en el arreglo
                    $validateInsert = DB::table('S002V01TNTWO')->insert([
                        'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                        'NTWO_IDTA' => $idTask,
                        'NTWO_IDUS' => $value,
                        'NTWO_TINO' => 'V',
                        'NTWO_SECU' => $count,
                        'NTWO_USRE' => $user,
                        'NTWO_FERE' => $currentDate,
                        'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la notificaciones de validación 1.", $th->getMessage(), 500);
                }
                if (!$validateInsert) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "No se pudo registrar las notificaciones", [], 500);
                }
                // Cada que se registre un usuario, su secuencia se incrementará
                $count++;
            }
        // En caso de existir información de usuarios para validar, entonces...
        } else {
            // En caso de que un usuario no se encuentre seleccionado en el formulario y este ya se haya registrado en la base de datos, 
            // entonces se obtiene su identificador en un arreglo para ser eliminado
            $arrRemoveUser = array();
            foreach ($arrNotification as $notification) {
                if (!in_array($notification, $requestData['USUARIO_VALIDACION'])) {
                    $arrRemoveUser[] = $notification;
                }
            }

            // Los usuarios que se encontraron para ser eliminados, su estado procede a ser eliminado
            try {
                $validateUpdate = DB::table('S002V01TNTWO')
                    ->where('NTWO_TINO', '=', 'V')
                    ->where('NTWO_IDTA', '=', $idTask)
                    ->where('NTWO_ESTA', '=', 'Activo')
                    ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->update([
                        'NTWO_ESTA' => 'Eliminado',
                        'NTWO_SECU' => 0,
                        'NTWO_USMO' => $user,
                        'NTWO_FEMO' => $currentDate,
                        'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar al otro usuario de notificación de validación 2.', $th->getMessage(), 406);
            }
            if (!$validateUpdate) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo modificar al otro usuario de notificación de validación. 2', [], 406);
            }

            $count = 1;
            foreach ($requestData['USUARIO_VALIDACION'] as $key => $validateUser) {
                try {
                    $validateInsert = DB::table('S002V01TNTWO')->insert([
                        'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                        'NTWO_IDTA' => $idTask,
                        'NTWO_IDUS' => $validateUser,
                        'NTWO_TINO' => 'V',
                        'NTWO_SECU' => $count,
                        'NTWO_USRE' => $user,
                        'NTWO_FERE' => $currentDate,
                        'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la notificaciones de validación 3.", $th->getMessage(), 500);
                }
                if (!$validateInsert) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "No se pudo registrar las notificaciones 3", [], 500);
                }
                $count++;
            }
        }

        try {
            $arrNotification = DB::table('S002V01TNTWO')
                ->where('NTWO_TINO', '=', 'N')
                ->where('NTWO_ESTA', '=', 'Activo')
                ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NTWO_IDTA', '=', $idTask)
                ->get([
                    'NTWO_IDUS AS ID_USUARIO',
                ]);
            $arrNotification = json_decode(json_encode($arrNotification), true);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error un al obtener el usuario de notificación de validación 7.', $th->getMessage(), 406);
        }
        $arrNotification = array_column($arrNotification, 'ID_USUARIO');
        
        if (empty($arrNotification)) {
            $count = 1;
            foreach ($requestData['NOTIFICAR_USUARIOS'] as $value) {
                try {
                    $validateInsert = DB::table('S002V01TNTWO')->insert([
                        'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                        'NTWO_IDTA' => $idTask,
                        'NTWO_IDUS' => $value,
                        'NTWO_TINO' => 'N',
                        'NTWO_SECU' => $count,
                        'NTWO_USRE' => $user,
                        'NTWO_FERE' => $currentDate,
                        'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la notificaciones de validación 8.", $th->getMessage(), 500);
                }
                if (!$validateInsert) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, "No se pudo registrar las notificaciones 8", [], 500);
                }
                $count++;
            }

        } else {
            $arrRemoveUser = array();
            foreach ($arrNotification as $notification) {
                if (!in_array($notification, $requestData['NOTIFICAR_USUARIOS'])) {
                    $arrRemoveUser[] = $notification;
                }
            }


            foreach ($arrRemoveUser as $removeUser) {
                try {
                    $validateUpdate = DB::table('S002V01TNTWO')
                        ->where('NTWO_TINO', '=', 'N')
                        ->where('NTWO_IDTA', '=', $idTask)
                        ->where('NTWO_ESTA', '=', 'Activo')
                        ->where('NTWO_IDUS', '=', $removeUser)
                        ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->update([
                            'NTWO_ESTA' => 'Eliminado',
                            'NTWO_USMO' => $user,
                            'NTWO_FEMO' => $currentDate,
                            'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar al otro usuario de notificación de validación 9.', $th->getMessage(), 406);
                }
                if (!$validateUpdate) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo modificar al otro usuario de notificación de validación. 9', [], 406);
                }
            }

            $count = 1;
            foreach ($requestData['NOTIFICAR_USUARIOS'] as $key => $notificateUser) {
                if (!in_array($notificateUser, $arrNotification)) {
                    try {
                        $validateInsert = DB::table('S002V01TNTWO')->insert([
                            'NTWO_NULI' => $requestData['NUMERO_LINEA'],
                            'NTWO_IDTA' => $idTask,
                            'NTWO_IDUS' => $notificateUser,
                            'NTWO_TINO' => 'N',
                            'NTWO_SECU' => $count,
                            'NTWO_USRE' => $user,
                            'NTWO_FERE' => $currentDate,
                            'NTWO_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                    } catch (\Throwable $th) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, "Ocurrió un error al registrar la notificaciones de validación 10.", $th->getMessage(), 500);
                    }
                    if (!$validateInsert) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, "No se pudo registrar las notificaciones", [], 500);
                    }
                    $count++;
                }
            }
        }

        try {
            $arrExecuteWorkflow = DB::table('S002V01TEJWO')
                ->where('EJWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EJWO_IDWO', '=', $requestData['ID_WORKFLOW'])
                ->where('EJWO_ESTA', '=', 'En proceso')
                ->get([
                    'EJWO_IDEW AS ID_EJECUCION_WORKFLOW',
                ]);
            $arrExecuteWorkflow = json_decode(json_encode($arrExecuteWorkflow), true);
            $arrExecuteWorkflow = array_column($arrExecuteWorkflow, 'ID_EJECUCION_WORKFLOW');
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones pendientes.', $th->getMessage(), 406);
        }

        $arrResendNotificate = array();
        foreach ($arrExecuteWorkflow as $executeWorkflow) {
            try {
                $arrExecuteTask = DB::table('S002V01TEJTW')
                    ->where('EJTW_IDEW', '=', $executeWorkflow)
                    ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('TAWO_ESTA', '=', 'Activo')
                    ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('PRWO_ESTA', '=', 'Asignado')
                    ->join('S002V01TTAWO', 'TAWO_IDTA', '=', 'EJTW_IDTA')
                    ->join('S002V01TPRWO', 'PRWO_IDPR', '=', 'TAWO_IDPR')
                    ->orderBy('TAWO_SECU', 'ASC')
                    ->get([
                        'EJTW_IDET AS ID_EJECUCION_TAREA',
                        'TAWO_SECU AS SECUENCIA',
                        'TAWO_IDWO AS ID_WORKFLOW',
                        'TAWO_IDTA AS ID_TAREA',
                        'PRWO_IDPR AS ID_PROCESO',
                        'PRWO_NOPR AS NOMBRE_PROCESO'
                    ]);
                $arrExecuteTask = json_decode(json_encode($arrExecuteTask), true);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones de las tareas.', $th->getMessage(), 406);
            }

            foreach ($arrExecuteTask as $keyExecuteTask => $executeTask) {

                if ($executeTask['SECUENCIA'] === 1) {
                    
                    $arrUpdate = [
                        'EJTW_ESTA' => 'En proceso',
                        'EJTW_USMO' => $user,
                        'EJTW_FEMO' => $currentDate,
                        'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                    ];
                } else {
                    $arrUpdate = [
                        'EJTW_INFO' => null,
                        'EJTW_INRE' => null,
                        'EJTW_ESTA' => 'En espera',
                        'EJTW_USMO' => $user,
                        'EJTW_FEMO' => $currentDate,
                        'EJTW_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                    ];
                }

                try {
                    $validateUpdate = DB::table('S002V01TEJTW')
                        ->where('EJTW_IDEW', '=', $executeWorkflow)
                        ->where('EJTW_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                        ->where('EJTW_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->update($arrUpdate);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar las ejecuciones de las tareas.', $th->getMessage(), 406);
                }
                if (!$validateUpdate) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo modificar las ejecuciones de las tareas.', [], 406);
                }

                try {
                    $validateExists = DB::table('S002V01TEJNO')
                        ->where('EJNO_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                        ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->exists();
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las ejecuciones de las notificaciones.', $th->getMessage(), 406);
                }
                if ($validateExists) {
                    try {
                        $validateUpdate = DB::table('S002V01TEJNO')
                            ->where('EJNO_IDET', '=', $executeTask['ID_EJECUCION_TAREA'])
                            ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                            ->update([
                                'EJNO_ESTA' => 'Obsoleto',
                                '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 las ejecuciones de las notificaciones.', $th->getMessage(), 406);
                    }
                    if (!$validateUpdate) {
                        DB::rollBack();
                        return $this->responseController->makeResponse(true, 'No se pudo modificar las ejecuciones de las notificaciones.', [], 406);
                    }
                }

                if ($executeTask['SECUENCIA'] === 1) {
                    $arrResendNotificate[] = [
                        'ID_EJECUCION_WORKFLOW' => $executeWorkflow,
                        'ID_WORKFLOW' => $executeTask['ID_WORKFLOW'],
                        'ID_TAREA' => $executeTask['ID_TAREA'],
                        'ID_EJECUCION_TAREA' => $executeTask['ID_EJECUCION_TAREA'],
                        'ID_PROCESO' => $executeTask['ID_PROCESO'],
                        'NOMBRE_PROCESO' => $executeTask['NOMBRE_PROCESO'],
                    ];
                }
            }

        }
        
        foreach ($arrResendNotificate as $resendNotificate) {
            try {
                $arrNotificate = DB::table('S002V01TNTWO')
                    ->where('NTWO_IDTA', '=', $executeTask['ID_TAREA'])
                    ->where('NTWO_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('NTWO_ESTA', '=', 'Activo')
                    ->orderBy('NTWO_SECU', 'ASC')
                    ->get([
                        'NTWO_IDUS AS USUARIO_NOTIFICACION',
                        'NTWO_TINO AS TIPO_NOTIFICACION',
                        'NTWO_SECU AS SECUENCIA',
                    ]);
                $arrNotificate = json_decode(json_encode($arrNotificate), true);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener las notificaciones.', $th->getMessage(), 406);
            }
            
            $userValidate = null;
            $notifacateUsers = array();
            foreach ($arrNotificate as $notificate) {

                try {
                    $validateRegister = DB::table('S002V01TEJNO')->insert([
                        'EJNO_NULI' => $requestData['NUMERO_LINEA'],
                        'EJNO_IDET' => $resendNotificate['ID_EJECUCION_TAREA'],
                        'EJNO_USNO' => $notificate['USUARIO_NOTIFICACION'],
                        'EJNO_SECU' => $notificate['SECUENCIA'],
                        'EJNO_TINO' => $notificate['TIPO_NOTIFICACION'],
                        'EJNO_ESTA' => $notificate['SECUENCIA'] === 1 || $notificate['TIPO_NOTIFICACION'] === 'N'  ? '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 notificaciones.', $th->getMessage(), 406);
                }
                if (!$validateRegister) {
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'No se pudo registrar las notificaciones.', [], 406);
                }
                
                if ($notificate['TIPO_NOTIFICACION'] === 'V' && $notificate['SECUENCIA'] === 1) {
                    $userValidate = $notificate['USUARIO_NOTIFICACION'];
                }

                if ($notificate['TIPO_NOTIFICACION'] === 'N') {
                    $notifacateUsers[] = $notificate['USUARIO_NOTIFICACION'];
                }
            }

            if (is_null($userValidate)) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "No se encontró el usuario para enviar la notificación para la validación de la ejecución #{$resendNotificate['ID_EJECUCION_TAREA']}.", [], 406);
            }
            
            $objExecute = [ 'ID' => $resendNotificate['ID_EJECUCION_WORKFLOW'], 'TYPE' => 'VALIDATE' ];
            $strExecuteWorkflow = json_encode($objExecute);
            $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

            $this->notificationsController->emitNotification(
                'S002V01M03GEPR',
                'Flujo de trabajo modificado.',
                "El flujo de trabajo #{$resendNotificate['ID_WORKFLOW']} ha sido modificado, por lo cual el proceso se ha reiniciado. Se le pide nuevamente realizar el proceso de validación.",
                [[
                    'BOTON' => 'Ver solicitud',
                    'FUNCION' => 'openModule',
                    'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/".$encExecuteWorkflow)]),
                ]],
                [$userValidate],
                $user,
                $requestData['NUMERO_LINEA'],
                $this->socketClient,
            );

            if (!empty($notifacateUsers)) {
                $objExecute = [ 'ID' => $resendNotificate['ID_EJECUCION_WORKFLOW'], 'TYPE' => 'NOTIFICATE' ];
                $strExecuteWorkflow = json_encode($objExecute);
                $encExecuteWorkflow = $this->encController->encrypt($strExecuteWorkflow);

                $this->notificationsController->emitNotification(
                    'S002V01M03GEPR',
                    'Flujo de trabajo modificado',
                    "El flujo de trabajo #{$resendNotificate['ID_WORKFLOW']} ha sido modificado, por lo cual el proceso se ha reiniciado.",
                    [[
                        'BOTON' => 'Ver solicitud',
                        'FUNCION' => 'openModule',
                        'PARAMETROS' => json_encode([$this->encController->encrypt("GEPR/SFTR/GSFT/".$encExecuteWorkflow)]),
                    ]],
                    [$notifacateUsers],
                    $user,
                    $requestData['NUMERO_LINEA'],
                    $this->socketClient,
                );
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Modificación Exitosa");
    }
    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
            );
        }

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

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

        $idTask = $this->encController->decrypt($idTask);
        if (is_null($idTask)) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar la tarea.', [], 500);
        }

        try {
            $arrTask = (array) DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('TAWO_ESTA', '=', 'Activo')
                ->first([
                    'TAWO_IDWO AS ID_WORKFLOW',
                    'TAWO_IDPR AS ID_PROCESO',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al obtener las tareas.", $th->getMessage(), 500);
        }
        
        if (empty($arrTask)) {
            return $this->responseController->makeResponse(true, "La tarea no existe.", [], 406);
        }

        try {
            $validateExists = DB::table('S002V01TEJTW')
                ->where('EJTW_IDTA', '=', $idTask)
                ->where('EJTW_ESTA', '!=', 'Rechazado')
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "Ocurrió un error al verificar la ejecución de los workflow.", $th->getMessage(), 500);
        }
        if ($validateExists) {
            return $this->responseController->makeResponse(true, "La tarea no puede ser eliminada ya que hay flujo de trabajo en proceso.", [], 406);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TTAWO')
                ->where('TAWO_IDTA', '=', $idTask)
                ->where('TAWO_ESTA', '=', 'Activo')
                ->where('TAWO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'TAWO_ESTA' => 'Eliminado',
                    '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 eliminar la tarea.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No se pudo eliminar la tarea.', [], 406);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Eliminación Exitosa");
    }


    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 searchNotificate(Request $request) {
        $validator = Validator::make($request->all(), [
            'NUMERO_NOTIFICACION' => 'nullable|integer',
            'USUARIO_NOTIFICACION' => 'nullable|string',
            'TIPO_NOTIFICACION' => 'nullable|string',
            'ESTADO_NOTIFICACION' => '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(
            'NUMERO_NOTIFICACION' => 'EJNO_IDEN',
            'USUARIO_NOTIFICACION' => 'EJNO_USNO',
            'TIPO_NOTIFICACION' => 'EJNO_TINO',
            'ESTADO_NOTIFICACION' => 'EJNO_ESTA',
        );

        $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('S002V01TEJNO')
                ->where($dataWhere)
                ->where('EJNO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->join('S002V01TUSUA', 'USUA_IDUS', '=', 'EJNO_USNO')
                ->get([
                    'EJNO_IDEN AS ID_NOTIFICACION',
                    'EJNO_IDET AS ID_EJECUCION_TAREA',
                    DB::raw('CONCAT(USUA_NOMB, " ", USUA_APPA, IF(ISNULL(USUA_APMA), "", CONCAT(" ", USUA_APMA)), " (", USUA_IDUS, ")") AS USUARIO_NOTIFICACION'),
                    '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',
                ]);
            $arrFilter = json_decode(json_encode($arrFilter), true);
        } 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($arrFilter, $requestData['NUMERO_LINEA']);
        if ($responseCheckLatestUpdate['error']) {
            return $this->responseController->makeResponse(true, $responseCheckLatestUpdate['msg'], [], 500);
        }
        $arrFilter = $responseCheckLatestUpdate['response'];

        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;
        }

        foreach ($arrDataFilter as $key => $value) {
            if ($value['TIPO_NOTIFICACION'] === 'V') {
                $value['TIPO_NOTIFICACION'] = 'Para validación';
            }
            if ($value['TIPO_NOTIFICACION'] === 'N') {
                $value['TIPO_NOTIFICACION'] = 'Para notificación';
            }
            $arrDataFilter[$key] = $value;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta exitosa", $arrDataFilter);
    }
    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);
    }

}