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

<?php

namespace App\Http\Controllers;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use Dompdf\Dompdf;
use Illuminate\Http\File;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Carbon;

class FailureAnalysisController extends Controller 
{
    private $responseController;
    private $encController;
    private $functionsController;
    private $resourcesController;

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


    public function getFailures($user, $line) {

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

        try {
            $arrFailures = DB::table('S002V01TLIFA')
                ->where('LIFA_NULI', '=', $line)
                ->get([
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LIFA_SOLU AS SOLICION',
                    'LIFA_DESC AS DESCRIPCION',
                    'LIFA_ESTA AS ESTADO',
                    'LIFA_USRE AS USUARIO_REGISTRA',
                    'LIFA_FERE AS FECHA_REGISTRA',
                    'LIFA_USMO AS USUARIO_MODIFICA',
                    'LIFA_FEMO AS FECHA_MODIFICA',
                ]);
            $arrFailures = json_decode(json_encode($arrFailures), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURES_GET000: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

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

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrFailures);
    }
    public function getFailuresActives($user, $line) {
        try {
            $getFailures = DB::table('S002V01TLIFA')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LIFA_NULI', '=', 1)
                ->get([
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LIFA_SOLU AS SOLICION',
                    'LIFA_DESC AS DESCRIPCION',
                    'LIFA_ESTA AS ESTADO',
                    'LIFA_USRE AS USUARIO_REGISTRA',
                    'LIFA_FERE AS FECHA_REGISTRA',
                    'LIFA_USMO AS USUARIO_MODIFICA',
                    'LIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURES_GET000: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }
        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $getFailures);
    }
    public function getFailureById($idFailure, $user, $line) {
        $idFailure = $this->encController->decrypt($idFailure);
        try {
            $arrFailures = (array) DB::table('S002V01TLIFA')
                ->where('LIFA_IDFA', '=', $idFailure)
                ->where('LIFA_NULI', '=', $line)
                ->where('LIFA_ESTA', '=', 'Activo')
                ->first([
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LIFA_SOLU AS SOLICION',
                    'LIFA_DESC AS DESCRIPCION',
                    'LIFA_ESTA AS ESTADO',
                    'LIFA_USRE AS USUARIO_REGISTRA',
                    'LIFA_FERE AS FECHA_REGISTRA',
                    'LIFA_USMO AS USUARIO_MODIFICA',
                    'LIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_GETBYID000: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }
        if ( !empty($arrFailures) ) {
            try {
                $arrEquipment = DB::table('S002V01TLFEQ')
                    ->where('LFEQ_IDFA', '=', $arrFailures['ID_FALLA'])
                    ->where('LFEQ_NULI', '=', $line)
                    ->where('LFEQ_ESTA', '=', 'Activo')
                    ->where('EQUI_NULI', '=', $line)
                    ->join('S002V01TEQUI', 'EQUI_COEQ', '=', 'LFEQ_COEQ')
                    ->get([
                        'EQUI_COEQ AS CODIGO',
                        'EQUI_TIPO AS TIPO',
                        'EQUI_MODE AS MODELO',
                        'EQUI_IDEQ AS ID_EQUIPO',
                        'EQUI_ESFU AS ESTADO_FUNCIONAMIENTO',
                        // 'EQUI_GAIM AS GALERIA_IMAGENES',
                        'EQUI_ELOR AS ELEMENTO_ORIGEN',
                        'EQUI_TICO AS TIPO_CODIGO'
                    ]);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_FAILURES_GETBYID001: No se pudo realizar la consulta a la base.", 
                    $th->getMessage(), 
                    500
                );
            }
    
            $arrEquipment = json_decode( json_encode($arrEquipment), true );

            foreach ($arrEquipment as $keyEquipment => $equipment) {
                $equipment['ID_EQUIPO'] = strval($equipment['ID_EQUIPO']);
                $arrEquipment[$keyEquipment] = $equipment;
            }
            $arrFailures['EQUIPAMIENTOS'] = $arrEquipment;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrFailures);
    }
    public function getFailureListByClassification($clasificate, $user, $line) {
        try {
            $clasificate = $this->encController->decrypt($clasificate);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURES_GETCLASS000: No se pudo obtener las clasificación.", $th->getMessage(), 500);
        }
        try {
            $getFailures = DB::table('S002V01TLIFA')
                ->where('LIFA_NIVE', '=', $clasificate)
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LIFA_NULI', '=', 1)
                ->get([
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LIFA_SOLU AS SOLICION',
                    'LIFA_DESC AS DESCRIPCION',
                    'LIFA_ESTA AS ESTADO',
                    'LIFA_USRE AS USUARIO_REGISTRA',
                    'LIFA_FERE AS FECHA_REGISTRA',
                    'LIFA_USMO AS USUARIO_MODIFICA',
                    'LIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURES_GETCLASS001: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }
        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $getFailures);
    }
    public function registerFailures(Request $request) {
        $validator = Validator::make($request->all(), [
            'NOMBRE_FALLA' => 'required|string',
            'NIVEL' => 'required|string',
            'CAUSA' => 'required|string',
            'SOLUCION' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'EQUIPAMIENTOS' => 'required',
            'NUMERO_LINEA' => 'required|integer',
            'USUARIO' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_FAILURES_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_REG001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

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

        try {
            $idFailure = DB::table('S002V01TLIFA')->insertGetId([
                'LIFA_NULI' => $requestData['NUMERO_LINEA'],
                'LIFA_NOFA' => $requestData['NOMBRE_FALLA'],
                'LIFA_NIVE' => $requestData['NIVEL'],
                'LIFA_CAUS' => $requestData['CAUSA'],
                'LIFA_SOLU' => $requestData['SOLUCION'],
                'LIFA_DESC' => $requestData['DESCRIPCION'],
                'LIFA_USRE' => $user,
                'LIFA_FERE' => $currentDate,
                'LIFA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse( 
                true, 
                "ERR_FAILURES_REG002: Ocurrió un error al registrar el formulario en la lista de falla.", 
                $th->getMessage(), 
                500
            );
        }
        if ( !$idFailure ) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_REG003: No se pudo registrar el formulario en la lista de falla.", 
                [], 
                500
            );
        }

        foreach ($requestData['EQUIPAMIENTOS'] as $keyEquipment => $equipment) {
            try {
                $validateRegisterEquipment = DB::table('S002V01TLFEQ')->insert([
                    'LFEQ_NULI' => $requestData['NUMERO_LINEA'],
                    'LFEQ_IDFA' => $idFailure,
                    'LFEQ_COEQ' => $equipment,
                    'LFEQ_USRE' => $user,
                    'LFEQ_FERE' => $currentDate,
                    'LFEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse( 
                    true, 
                    "ERR_FAILURES_REG004: Ocurrió un error al registrar el formulario en la lista de falla.", 
                    $th->getMessage(), 
                    500
                );
            }

            if ( !$validateRegisterEquipment ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_FAILURES_REG005: No se pudo registrar el equipamiento $equipment en la lista de fallas.", 
                    [], 
                    500
                );
            }
        }
        
        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateFailures(Request $request) {
        $validator = Validator::make($request->all(), [
            'ID_FALLA' => 'required|integer',
            'NOMBRE_FALLA' => 'required|string',
            'NIVEL' => 'required|string',
            'CAUSA' => 'required|string',
            'SOLUCION' => 'required|string',
            'DESCRIPCION' => 'required|string',
            'EQUIPAMIENTOS' => 'required',
            'NUMERO_LINEA' => 'required|integer',
            'USUARIO' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_FAILURES_UPD000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();
        try {
            $user = $this->encController->decrypt($request['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_UPD001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

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

        try {
            $idFailure = DB::table('S002V01TLIFA')
                ->where('LIFA_NULI', '=', $requestData['NUMERO_LINEA'])    
                ->where('LIFA_IDFA', '=', $requestData['ID_FALLA'])    
                ->update([
                    'LIFA_NOFA' => $requestData['NOMBRE_FALLA'],
                    'LIFA_NIVE' => $requestData['NIVEL'],
                    'LIFA_CAUS' => $requestData['CAUSA'],
                    'LIFA_SOLU' => $requestData['SOLUCION'],
                    'LIFA_DESC' => $requestData['DESCRIPCION'],
                    'LIFA_USMO' => $user,
                    'LIFA_FEMO' => $currentDate,
                    'LIFA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse( 
                true, 
                "ERR_FAILURES_UPD002: Ocurrió un error al modificar el formulario en la lista de falla.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$idFailure ) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_UPD003: No se pudo modificar el formulario en la lista de falla.", 
                [], 
                500
            );
        }

        foreach ($requestData['EQUIPAMIENTOS'] as $keyEquipment => $equipment) {
            try {
                $validateExists = DB::table('S002V01TLFEQ')
                    ->where('LFEQ_IDFA', '=', $requestData['ID_FALLA'])
                    ->where('LFEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('LFEQ_COEQ', '=', $equipment)
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_FAILURES_UPD004: Ocurrió un error al consultar el equipamiento.", 
                    $th->getMessage(), 
                    500
                );
            }
    
            if ( $validateExists ) {
                try {
                    $validate = DB::table('S002V01TLFEQ')
                        ->where('LFEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('LFEQ_IDFA', '=', $requestData['ID_FALLA'])
                        ->where('LFEQ_COEQ', '=', $equipment)
                        ->update([
                            'LFEQ_ESTA' => 'Activo',
                            'LFEQ_USMO' => $user,
                            'LFEQ_FEMO' => $currentDate,
                            'LFEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_FAILURES_UPD005: Ocurrió un error al modificar el formulario en la lista de falla el equipamiento $equipment.", 
                        $th->getMessage(), 
                        500
                    );
                }
            } else {
                try {
                    $validate = DB::table('S002V01TLFEQ')->insert([
                        'LFEQ_NULI' => $requestData['NUMERO_LINEA'],
                        'LFEQ_IDFA' => $requestData['ID_FALLA'],
                        'LFEQ_COEQ' => $equipment,
                        'LFEQ_USRE' => $user,
                        'LFEQ_FERE' => $currentDate,
                        'LFEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_FAILURES_UPD006: Ocurrió un error al registrar el formulario en la lista de falla el equipamiento $equipment.", 
                        $th->getMessage(), 
                        500
                    );
                }
            }
            if ( !$validate ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_FAILURES_UPD007: No se pudo modificar el equipamiento $equipment en la lista de fallas.", 
                    [], 
                    500
                );
            }
        }

        try {
            $getListEquipment = DB::table('S002V01TLFEQ')
                ->where('LFEQ_IDFA', '=', $requestData['ID_FALLA'])
                ->where('LFEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                ->get([
                    'LFEQ_IDLF',
                    'LFEQ_IDFA',
                    'LFEQ_COEQ',
                    'LFEQ_ESTA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_UPD008: Ocurrió un error al consultar la lista de equipamientos.", 
                $th->getMessage(), 
                500
            );
        }

        $arrListEquipment = json_decode( json_encode($getListEquipment), true );
        
        foreach ($arrListEquipment as $keyListEquipment => $listEquipment) {
            if( !in_array($listEquipment['LFEQ_COEQ'], $requestData['EQUIPAMIENTOS']) ) {
                try {
                    $validateDelete = DB::table('S002V01TLFEQ')
                        ->where('LFEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('LFEQ_IDFA', '=', $requestData['ID_FALLA'])
                        ->where('LFEQ_COEQ', '=', $listEquipment['LFEQ_COEQ'])
                        ->update([
                            'LFEQ_ESTA' => 'Eliminado',
                            'LFEQ_USMO' => $user,
                            'LFEQ_FEMO' => $currentDate,
                            'LFEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_FAILURES_UPD009: Ocurrió un error al eliminar de la lista de falla el equipamiento ". $listEquipment['LFEQ_COEQ'].".", 
                        $th->getMessage(), 
                        500
                    );
                }

                if ( !$validateDelete ) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_FAILURES_UPD010: No se pudo eliminar de la lista de falla el equipamiento ". $listEquipment['LFEQ_COEQ'].".", 
                        [], 
                        500
                    );
                }
            }
        }
        
        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Modificación Exitosa");
    }
    public function deleteFailures(Request $request) {
        $validator = Validator::make($request->all(), [
            'ID_FALLA' => 'required|integer',
            'NUMERO_LINEA' => 'required|integer',
            'USUARIO' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_FAILURES_DEL000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();
        
        try {
            $user = $this->encController->decrypt($request['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }
        
        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        try {
            $exist = DB::table('S002V01TLIFA')
                ->where('LIFA_IDFA', '=', $requestData['ID_FALLA'])
                ->where('LIFA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL002: Ocurrió un error al consultar en la base de datos.", $th->getMessage(), 500);
        }
        
        if (!$exist) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL003: No se pudo encontrar el registro dentro de la base de datos.", [], 500);
        }

        try {
            $validateUpdate = DB::table('S002V01TLIFA')
                ->where('LIFA_IDFA', '=', $requestData['ID_FALLA'])
                ->where('LIFA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LIFA_ESTA' => 'Eliminado',
                    'LIFA_USMO' => $user,
                    'LIFA_FEMO' => $currentDate,
                    'LIFA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL004: Ocurrió un error al modificar el formulario en la base de datos.", $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL005: No se pudo modificar el formulario en la base de datos.", [], 500);
        }

        try {
            $validateDelete = DB::table('S002V01TLFEQ')
                ->where('LFEQ_IDFA', '=', $requestData['ID_FALLA'])
                ->where('LFEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LFEQ_ESTA' => 'Eliminado',
                    'LFEQ_USMO' => $user,
                    'LFEQ_FEMO' => $currentDate,
                    'LFEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_DEL006: Ocurrió un error al eliminar la lista de equipamientos.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$validateDelete ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_DEL007: No se pudo eliminar la lista de equipamientos.", [], 500);
        }

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



    public function getFailureLog($user, $line) {

        try {
            $getFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NULI', '=', $line)
                ->where('LIFA_NULI', '=', $line)
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->get([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'BIFA_ESTA AS ESTADO',
                    'BIFA_USRE AS USUARIO_REGISTRA',
                    'BIFA_FERE AS FECHA_REGISTRA',
                    'BIFA_USMO AS USUARIO_MODIFICA',
                    'BIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GET000: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLog = json_decode( json_encode( $getFailureLog ), true );

        $arrEquipmentCode = array_column($arrFailureLog, 'CODIGO_EQUIPAMIENTO');
        $arrEquipmentCode = array_unique($arrEquipmentCode);

        $count = 0;
        $arrEquipmentFailureLog = array();
        foreach ($arrEquipmentCode as $keyEquipmentCode => $equipmentCode) {
            $lastUpdate = '';
            $lastUser = '';
            $lastState = '';
            $lastClassification = '';
            $amountFailures = 0;
            foreach ($arrFailureLog as $keyFailureLog => $failureLog) {
                if ( $equipmentCode === $failureLog['CODIGO_EQUIPAMIENTO'] ) {
                
                    $tempLastUpdate = '';
                    $tempLastUser = '';
                    if ( is_null($failureLog['FECHA_MODIFICA']) ) {
                        $tempLastUpdate = $failureLog['FECHA_REGISTRA'];
                        $tempLastUser = $failureLog['USUARIO_REGISTRA'];
                    } else {
                        $tempLastUpdate = $failureLog['FECHA_MODIFICA'];
                        $tempLastUser = $failureLog['USUARIO_MODIFICA'];
                    }

                    if ($lastUpdate === '') {
                        $lastUpdate = $tempLastUpdate;
                        $lastUser = $tempLastUser;
                        $lastState = $failureLog['ESTADO_FALLA'];
                        $lastClassification = $failureLog['NIVEL_CRITICIDAD_FALLA'];
                    } else {
                        $carTempLastUpdate = Carbon::create($tempLastUpdate);
                        $carLastState = Carbon::create($lastUpdate);

                        if ($carTempLastUpdate->greaterThan($carLastState)) {
                            $lastUpdate = $tempLastUpdate;
                            $lastUser = $tempLastUser;
                            $lastState = $failureLog['ESTADO_FALLA'];
                            $lastClassification = $failureLog['NIVEL_CRITICIDAD_FALLA'];
                        }
                    }
                    $amountFailures ++;
                }
            }

            $arrEquipmentFailureLog[$count]['CODIGO_EQUIPAMIENTO'] = $equipmentCode;
            $arrEquipmentFailureLog[$count]['ULTIMA_MODIFICACION'] = $lastUpdate;
            $arrEquipmentFailureLog[$count]['ULTIMO_USUARIO'] = $lastUser;
            $arrEquipmentFailureLog[$count]['ESTADO_ACTUAL'] = $lastState;
            $arrEquipmentFailureLog[$count]['CLASIFICACION_ACTUAL'] = $lastClassification;
            $arrEquipmentFailureLog[$count]['CANTIDAD_FALLAS'] = $amountFailures;

            $count++;
        }
        

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrEquipmentFailureLog);
    }
    public function getHistoryFailureEquipment($equipment, $user, $line) {

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, $arrResponseCheckUser['msg'], [], 401);
        }
        
        try {
            $equipment = $this->encController->decrypt($equipment);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_GETHISTORY_GETEQUIPMENT000", $th->getMessage(), 500);
        }

        try {
            $getFailuresLog = DB::table('S002V01TBIFA')
                ->where('BIFA_COEQ', '=', $equipment)
                ->where('BIFA_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->get([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'BIFA_USRE AS USUARIO_REGISTRA',
                    'BIFA_FERE AS FECHA_REGISTRA',
                    'BIFA_USMO AS USUARIO_MODIFICA',
                    'BIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_GETHISTORY_GETEQUIPMENT001: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLogTemp = json_decode( json_encode( $getFailuresLog ), true );

        $arrFailureLog = array();
        foreach ($arrFailureLogTemp as $keyFailureLogTemp => $failureLogTemp) {
            $numero_falla = $failureLogTemp['NUMERO_FALLA'];

            $nombre_falla = $failureLogTemp['NOMBRE_FALLA'].' ('.$failureLogTemp['ID_FALLA'].')';

            $nivel_criticidad_falla = $failureLogTemp['NIVEL_CRITICIDAD_FALLA'];

            $nombre_sintoma = $failureLogTemp['NOMBRE_SINTOMA'].' ('.$failureLogTemp['ID_SINTOMA'].')';

            $estado_falla = $failureLogTemp['ESTADO_FALLA'];

            $causa = $failureLogTemp['CAUSA_FALLA'];

            $fecha_fala = $failureLogTemp['FECHA_FALLA'];

            $reparable = $failureLogTemp['REPARABLE'] === 1 ? 'Si' : 'No';

            $arrFailureLog[] = [
                'NUMERO_FALLA' => $numero_falla,
                'NOMBRE_FALLA' => $nombre_falla,
                'NIVEL_CRITICIDAD_FALLA' => $nivel_criticidad_falla,
                'ESTADO_FALLA' => $estado_falla,
                'CAUSA' => $causa,
                'FECHA_FALLA' => $fecha_fala,
                'REPARABLE' => $reparable,
                'USUARIO_REGISTRA' => $failureLogTemp['USUARIO_REGISTRA'],
                'FECHA_REGISTRA' => $failureLogTemp['FECHA_REGISTRA'],
                'USUARIO_MODIFICA' =>$failureLogTemp['USUARIO_MODIFICA'],
                'FECHA_MODIFICA' => $failureLogTemp['FECHA_MODIFICA'],
            ];
        }

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

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrFailureLog);
    }
    public function getDetailsHistoryFailureEquipment($failure, $user, $line) {
        try {
            $failure = $this->encController->decrypt($failure);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_GETHISTORY_GETEQUIPMENT000", $th->getMessage(), 500);
        }

        try {
            $getFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NUFA', '=', $failure)
                ->where('BIFA_NULI', '=', $line)
                ->where('LIFA_NULI', '=', $line)
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->first([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_FERF AS FECHA_RESOLUCION',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GETACTIVE000: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLog = json_decode( json_encode( $getFailureLog ), true );

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrFailureLog);
    }
    public function getFailureLogActives($user, $line) {

        try {
            $getFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NULI', '=', $line)
                ->where('LIFA_NULI', '=', $line)
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->get([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'BIFA_USRE AS USUARIO_REGISTRA',
                    'BIFA_FERE AS FECHA_REGISTRA',
                    'BIFA_USMO AS USUARIO_MODIFICA',
                    'BIFA_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GETACTIVE000: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLog = json_decode( json_encode( $getFailureLog ), true );

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrFailureLog);
    }
    public function getEquipmentByFailure($failure, $user, $line) {

        try {
            $failure = $this->encController->decrypt($failure);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_EQUIPMENT000: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }
        try {
            $getEquipmentByFailure = DB::table('S002V01TBIFA')
                ->where('BIFA_IDFA', '=', $failure)
                ->where('BIFA_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->get([
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_FERF AS FECHA_REPARACION',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURES_EQUIPMENT001: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }
        
        $arrFaultyEquipment = json_decode(json_encode($getEquipmentByFailure), true);

        $arrEquipmentCode = array_column($arrFaultyEquipment, 'CODIGO_EQUIPAMIENTO');
        $arrEquipmentCode = array_unique($arrEquipmentCode);

        $count = 0;
        $arrEquipmentFailureLog = array();
        foreach ($arrEquipmentCode as $keyEquipmentCode => $equipmentCode) {
            foreach ($arrFaultyEquipment as $keyFaultyEquipment => $faultyEquipment) {
                if ( $equipmentCode === $faultyEquipment['CODIGO_EQUIPAMIENTO'] ) {
                    $arrEquipmentFailureLog[$count]['CODIGO_EQUIPAMIENTO'] = $faultyEquipment['CODIGO_EQUIPAMIENTO'];
                    $arrEquipmentFailureLog[$count]['DETALLES'][] = [
                        'ESTADO_FALLA' => $faultyEquipment['ESTADO_FALLA'], 
                        'FECHA_FALLA' => $faultyEquipment['FECHA_FALLA'], 
                        'FECHA_REPARACION' => $faultyEquipment['FECHA_REPARACION'], 
                        'VALOR_OBTENIDO' => $faultyEquipment['VALOR_OBTENIDO'], 
                        'ID_MEDIDA' => $faultyEquipment['ID_MEDIDA'], 
                        'NOMBRE_MEDIDA' => $faultyEquipment['NOMBRE_MEDIDA'], 
                        'ACRONIMO_MEDIDA' => $faultyEquipment['ACRONIMO_MEDIDA'], 
                    ];
                }
            }

            $count++;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrEquipmentFailureLog);
    }
    public function getAlarmEmissionFromFailures($user, $line) {
        try {
            $getAlarmEmission = DB::table('S002V01TBIFA')
                ->where('BIFA_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('ACTI_NULI', '=', $line)
                ->join('S002V01TACTI', 'ACTI_IDAC', '=', 'BIFA_IDAC')
                ->get([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'ACTI_IDAC AS ID_ACTIVADOR',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'ACTI_PRIO AS PRIORIDAD',
                    'ACTI_TIAC AS TIPO_ACTIVADOR',
                    'ACTI_COAC AS CONDICION_ACTIVADOR',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURES_ALARM000: No se pudo obtener la información de la base de datos.", $th->getMessage(), 500);
        }

        $arrAlarmEmission = json_decode(json_encode($getAlarmEmission), true);

        foreach ($arrAlarmEmission as $key => $alarmEmission) {
            
            switch ($alarmEmission['PRIORIDAD']) {
                case 1:
                    $alarmEmission['PRIORIDAD'] = 'Muy alta';
                    break;
                case 2:
                    $alarmEmission['PRIORIDAD'] = 'Alta';
                    break;
                case 3:
                    $alarmEmission['PRIORIDAD'] = 'Media';
                    break;
                case 4:
                    $alarmEmission['PRIORIDAD'] = 'Baja';
                    break;
            }

            $arrAlarmEmission[$key] = $alarmEmission;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrAlarmEmission);
    }
    public function generateSheetFailureXLS($failure, $user, $line) {
        try {
            $failure = $this->encController->decrypt($failure);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEXLS000", $th->getMessage(), 500);
        }
        try {
            $user = $this->encController->decrypt($user);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEXLS001", $th->getMessage(), 500);
        }

        try {
            $getFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NUFA', '=', $failure)
                ->where('BIFA_NULI', '=', $line)
                ->where('LIFA_NULI', '=', $line)
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->first([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_FERF AS FECHA_RESOLUCION',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEXLS002: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLog = json_decode( json_encode( $getFailureLog ), true );

        $spreadsheet = new Spreadsheet();
        $activeWorksheet = $spreadsheet->getActiveSheet()->setTitle($arrFailureLog['NUMERO_FALLA']);

        $activeWorksheet->setCellValue("A1", 'Número de Falla');
        $activeWorksheet->setCellValue("B1", $arrFailureLog['NUMERO_FALLA']);
        $activeWorksheet->getStyle( "A1" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A2", 'Número de Equipamiento');
        $activeWorksheet->setCellValue("B2", $arrFailureLog['CODIGO_EQUIPAMIENTO']);
        $activeWorksheet->getStyle( "A2" )->getFont()->setBold(true);
        
        $activeWorksheet->setCellValue("A3", 'Estado de la Falla');
        $activeWorksheet->setCellValue("B3", $arrFailureLog['ESTADO_FALLA']);
        $activeWorksheet->getStyle( "A3" )->getFont()->setBold(true);
        
        $activeWorksheet->setCellValue("A4", 'Nombre de la Falla');
        $activeWorksheet->setCellValue("B4", $arrFailureLog['NOMBRE_FALLA'].' ('.$arrFailureLog['ID_FALLA'].')');
        $activeWorksheet->getStyle( "A4" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A5", 'Nivel de Criticidad de la Falla');
        $activeWorksheet->setCellValue("B5", $arrFailureLog['NIVEL_CRITICIDAD_FALLA']);
        $activeWorksheet->getStyle( "A5" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A6", 'Causa de la Falla');
        $activeWorksheet->setCellValue("B6", $arrFailureLog['CAUSA_FALLA']);
        $activeWorksheet->getStyle( "A6" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A7", 'Nombre del Síntoma');
        $activeWorksheet->setCellValue("B7", $arrFailureLog['NOMBRE_SINTOMA'].' ('.$arrFailureLog['ID_SINTOMA'].')');
        $activeWorksheet->getStyle( "A7" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A8", 'Clasificación del Síntoma');
        $activeWorksheet->setCellValue("B8", $arrFailureLog['CLASIFICACION_SINTOMA']);
        $activeWorksheet->getStyle( "A8" )->getFont()->setBold(true);
    
        $activeWorksheet->setCellValue("A9", 'Causa del Síntoma');
        $activeWorksheet->setCellValue("B9", $arrFailureLog['CAUSA_SINTOMA']);
        $activeWorksheet->getStyle( "A9" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A10", 'Fecha de la Falla');
        $activeWorksheet->setCellValue("B10", $arrFailureLog['FECHA_FALLA']);
        $activeWorksheet->getStyle( "A10" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A11", 'Fecha de la Resolución');
        $activeWorksheet->setCellValue("B11", $arrFailureLog['FECHA_RESOLUCION']);
        $activeWorksheet->getStyle( "A11" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A12", 'Reparable');
        $activeWorksheet->setCellValue("B12", $arrFailureLog['REPARABLE'] === 1 ? 'Si' : 'No');
        $activeWorksheet->getStyle( "A12" )->getFont()->setBold(true);
        
        $activeWorksheet->setCellValue("A13", 'Valor Obtenido');
        $activeWorksheet->setCellValue("B13", $arrFailureLog['VALOR_OBTENIDO'].' '.$arrFailureLog['ACRONIMO_MEDIDA']);
        $activeWorksheet->getStyle( "A13" )->getFont()->setBold(true);

        $activeWorksheet->setCellValue("A14", 'Tipo de Medido');
        $activeWorksheet->setCellValue("B14", $arrFailureLog['NOMBRE_MEDIDA']);
        $activeWorksheet->getStyle( "A14" )->getFont()->setBold(true);
        
        $activeWorksheet->setCellValue("A15", 'Solución de la Falla');
        $activeWorksheet->setCellValue("B15", $arrFailureLog['SOLUCION'] === null || $arrFailureLog['SOLUCION'] === '' ? '' : $arrFailureLog['SOLUCION']);
        $activeWorksheet->getStyle( "A15" )->getFont()->setBold(true);
        
        $activeWorksheet->setCellValue("A16", 'Comentarios');
        $activeWorksheet->setCellValue("B16", $arrFailureLog['COMENTARIOS']);
        $activeWorksheet->getStyle( "A16" )->getFont()->setBold(true);


        $activeWorksheet->getColumnDimension("A")->setAutoSize(true);
        $activeWorksheet->getColumnDimension("B")->setAutoSize(true);


        $nuli = $this->resourcesController->formatSecuence($line, 2);
        $como = 'ANFA';         // Código del módulo
        $cldo = 'IN';           // Código de la clasificación
        $fecr = date('ymd');    // Fecha en la se carga el archivo

        try {
            $arrSecuence = (array) DB::table('S002V01TAFAL')
                ->where('AFAL_COMO', '=', $como)
                ->where('AFAL_CLDO', '=', $cldo)
                ->where('AFAL_NULI', '=', $line)
                ->orderBy('AFAL_NUSE', 'desc')
                ->first([ 'AFAL_NUSE' ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEXLS003: Ocurrió un error al obtener la información de la secuencia.", 
                $th->getMessage(), 
                500
            );
        }
        $nuse = 1;              // Secuencia del documento
        if ( !empty( $arrSecuence ) && !is_null( $arrSecuence ) ) {
            $nuse = intval( $arrSecuence['AFAL_NUSE'] ) + 1; 
        }
        $nuse = $this->resourcesController->formatSecuence($nuse, 6);
        $nuve = $this->resourcesController->formatSecuence('1', 2);
        $noar = 'ficha_de_falla_'.$arrFailureLog['NUMERO_FALLA'];
        $exte = 'xlsx';

        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $filePath = 'C:/ITTEC/SAM/Dev/SistemaMantenimiento/sistema-mantenimiento-back/public/public_files/';    // API JEAN
        } else {
            $filePath = 'C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\public_files\\';     // API QA
        }
        
        $fileName = $nuli.'-'.$como.'-'.$cldo.'-'.$fecr.'-'.$nuse.'='.$nuve.'='.$noar.'.'.$exte;

        $tempFile = $filePath.$fileName;

        if ( file_exists( $tempFile ) ) {
            if ( !unlink( $tempFile ) ) {
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_FAILURELOG_GENERATEXLS004: Ocurrió un error al eliminar el siguiente archivo: " . $tempFile, 
                    [], 
                    500
                );
            }
        }
        
        try {
            $writer = new Xlsx($spreadsheet);
            ob_start();
            $writer->save('php://output');
            $base64 = base64_encode(ob_get_clean());
            $validate = \File::put( $tempFile, base64_decode($base64));
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEXLS005: Ocurrió un error al guardar el documento.", 
                $th->getMessage(), 
                500
            );
        }

        $ubic = Storage::putFile('files', new File($tempFile));
        $ubic = str_replace("/", "\\", $ubic);
        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $ubic = "C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\storage\app\\" . $ubic;
        } else {
            $ubic = "C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\storage\app\\" . $ubic;
        }
        $tama = filesize($ubic);
        $usac = json_encode([$user]);

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

        try {
            $validateInsert = DB::table('S002V01TAFAL')->insert([
                'AFAL_NULI' => $line,
                'AFAL_COMO' => $como,
                'AFAL_CLDO' => $cldo,
                'AFAL_FECR' => $fecr,
                'AFAL_NUSE' => $nuse,
                'AFAL_NUVE' => $nuve,
                'AFAL_NOAR' => $noar,
                'AFAL_EXTE' => $exte,
                'AFAL_TAMA' => $tama,
                'AFAL_UBIC' => $ubic,
                'AFAL_USAC' => $usac,
                'AFAL_USRE' => $user,
                'AFAL_FERE' => $currentDate,
            ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEXLS006: Ocurrió un error guardar los datos a la tabla final de archivos.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$validateInsert ) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEXLS007: No se pudo guardar la ficha del proveedor en la base de datos.", 
                [], 
                500
            );
        }
        
        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $urlPublic = 'http://192.168.100.105:8000/public_files/' . $fileName;
        } else {
            $urlPublic = $this->functionsController->getApiURI().'sam/public_files/' . $fileName;
        }

        return $this->responseController->makeResponse(false, "EXITO: Modificación Exitosa", [ 'url' => $urlPublic ]);

        return $arrFailureLog;
    }
    public function generateSheetFailurePDF($failure, $user, $line){
        try {
            $failure = $this->encController->decrypt($failure);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEPDF000: Ocurrió un error al obtener la falla.", $th->getMessage(), 500);
        }
        try {
            $user = $this->encController->decrypt($user);    
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEPDF001: Ocurrió un error al obtener el usuario.", $th->getMessage(), 500);
        }
        try {
            $getFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NUFA', '=', $failure)
                ->where('BIFA_NULI', '=', $line)
                ->where('LIFA_NULI', '=', $line)
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('BIFA_ESTA', '=', 'Activo')
                ->where('LIFA_ESTA', '=', 'Activo')
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'BIFA_IDFA')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'BIFA_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'BIFA_IDME')
                ->first([
                    'BIFA_NUFA AS NUMERO_FALLA',
                    'BIFA_COEQ AS CODIGO_EQUIPAMIENTO',
                    'BIFA_ESFA AS ESTADO_FALLA',
                    'LIFA_IDFA AS ID_FALLA',
                    'LIFA_NOFA AS NOMBRE_FALLA',
                    'LIFA_NIVE AS NIVEL_CRITICIDAD_FALLA',
                    'LIFA_CAUS AS CAUSA_FALLA',
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION_SINTOMA',
                    'LISI_CAUS AS CAUSA_SINTOMA',
                    'BIFA_FEFA AS FECHA_FALLA',
                    'BIFA_FERF AS FECHA_RESOLUCION',
                    'BIFA_REPA AS REPARABLE',
                    'BIFA_DESO AS SOLUCION',
                    'BIFA_COME AS COMENTARIOS',
                    'BIFA_VAOB AS VALOR_OBTENIDO',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_GENERATEPDF002: No se pudo realizar la consulta a la base.", $th->getMessage(), 500);
        }

        $arrFailureLog = json_decode( json_encode( $getFailureLog ), true );
        // return $arrFailureLog;
        $html = '<!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Document</title>
            <style>
                body {
                    font-family: Arial, Helvetica, sans-serif;
                    font-size: 8pt;
                }
                .section-title { 
                    margin: 20px 0;
                    font-size: 12pt;
                }

                table {
                    width: 100%;
                }

                thead tr th {
                    text-align: start;
                    padding: 0 16px;
                    height: 52px;
                    border-bottom-width: 1px;
                    border-bottom-style: solid;
                    border-bottom-color: #CCC;
                }

                tbody tr td {
                    padding: 0 16px;
                    height: 52px;
                    border-bottom-width: 1px;
                    border-bottom-style: solid;
                    border-bottom-color: #CCC;
                }

                p {
                    text-align: justify;
                }

            </style>
        </head>
        <body>
            <div class="item">
                <b>Número de Falla: </b>
                <span>'.$arrFailureLog['NUMERO_FALLA'].'</span>
            </div>
            <div class="item">
                <b>Número de Equipamiento: </b>
                <span>'.$arrFailureLog['CODIGO_EQUIPAMIENTO'].'</span>
            </div>
            <div class="item">
                <b>Estado de la Falla: </b>
                <span>'.$arrFailureLog['ESTADO_FALLA'].'</span>
            </div>
            <div class="item">
                <b>Nombre de la Falla: </b>
                <span>'.$arrFailureLog['NOMBRE_FALLA'].' ('.$arrFailureLog['ID_FALLA'].')'.'</span>
            </div>
            <div class="item">
                <b>Nivel de Criticidad de la Falla: </b>
                <span>'.$arrFailureLog['NIVEL_CRITICIDAD_FALLA'].'</span>
            </div>
            <div class="item">
                <b>Causa de la Falla: </b>
                <span>'.$arrFailureLog['CAUSA_FALLA'].'</span>
            </div>
            <div class="item">
                <b>Nombre del Síntoma: </b>
                <span>'.$arrFailureLog['NOMBRE_SINTOMA'].' ('.$arrFailureLog['ID_SINTOMA'].')'.'</span>
            </div>
            <div class="item">
                <b>Clasificación del Síntoma: </b>
                <span>'.$arrFailureLog['CLASIFICACION_SINTOMA'].'</span>
            </div>
            <div class="item">
                <b>Causa del Síntoma: </b>
                <span>'.$arrFailureLog['CAUSA_SINTOMA'].'</span>
            </div>
            <div class="item">
                <b>Fecha de la Falla: </b>
                <span>'.$arrFailureLog['FECHA_FALLA'].'</span>
            </div>
            <div class="item">
                <b>Fecha de la Resolución: </b>
                <span>'.$arrFailureLog['FECHA_RESOLUCION'].'</span>
            </div>
            <div class="item">
                <b>Reparable: </b>
                <span>'.(($arrFailureLog['REPARABLE'] === 1) ? ('Si') : ('No')).'</span>
            </div>
            <div class="item">
                <b>Valor Obtenido: </b>
                <span>'.$arrFailureLog['VALOR_OBTENIDO'].' '.$arrFailureLog['ACRONIMO_MEDIDA'].'</span>
            </div>
            <div class="item">
                <b>Tipo de Medido: </b>
                <span>'.$arrFailureLog['NOMBRE_MEDIDA'].'</span>
            </div>
            <div class="item">
                <b>Solución de la Falla: </b>
                <span>'.(($arrFailureLog['SOLUCION'] === null || $arrFailureLog['SOLUCION'] === '') ? ('') : ($arrFailureLog['SOLUCION'])).'</span>
            </div>
            <div class="item">
                <b>Comentarios: </b>
                <span>'.$arrFailureLog['COMENTARIOS'].'</span>
            </div>';
        $html .= '</body></html>';

        $nuli = $this->resourcesController->formatSecuence($line, 2);
        $como = 'ANFA';         // Código del módulo
        $cldo = 'IN';           // Código de la clasificación
        $fecr = date('ymd');    // Fecha en la se carga el archivo

        try {
            $arrSecuence = (array) DB::table('S002V01TAFAL')
                ->where('AFAL_COMO', '=', $como)
                ->where('AFAL_CLDO', '=', $cldo)
                ->where('AFAL_NULI', '=', $line)
                ->orderBy('AFAL_NUSE', 'desc')
                ->first([ 'AFAL_NUSE' ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEPDF003: Ocurrió un error al obtener la información de la secuencia.", 
                $th->getMessage(), 
                500
            );
        }
        $nuse = 1;              // Secuencia del documento
        if ( !empty( $arrSecuence ) && !is_null( $arrSecuence ) ) {
            $nuse = intval( $arrSecuence['AFAL_NUSE'] ) + 1; 
        }
        $nuse = $this->resourcesController->formatSecuence($nuse, 6);
        $nuve = $this->resourcesController->formatSecuence('1', 2);
        $noar = 'ficha_de_proveedor_' . $arrFailureLog['NUMERO_FALLA'];

        $nuli = $this->resourcesController->formatSecuence($line, 2);
        $como = 'GEAD';         // Código del módulo
        $cldo = 'IN';           // Código de la clasificación
        $fecr = date('ymd');    // Fecha en la se carga el archivo
        try {
            $arrSecuence = (array) DB::table('S002V01TAFAL')
                ->where('AFAL_COMO', '=', $como)
                ->where('AFAL_CLDO', '=', $cldo)
                ->where('AFAL_NULI', '=', $line)
                ->orderBy('AFAL_NUSE', 'desc')
                ->first([ 'AFAL_NUSE' ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEPDF004: Ocurrió un error al obtener la información de la secuencia.", 
                $th->getMessage(), 
                500
            );
        }
        $nuse = 1;              // Secuencia del documento
        if ( !empty( $arrSecuence ) && !is_null( $arrSecuence ) ) {
            $nuse = intval( $arrSecuence['AFAL_NUSE'] ) + 1; 
        }
        $nuse = $this->resourcesController->formatSecuence($nuse, 6);
        $nuve = $this->resourcesController->formatSecuence('1', 2);
        $noar = 'ficha_de_falla_' . $arrFailureLog['NUMERO_FALLA'];
        $exte = 'pdf';        
        
        
        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $filePath = 'C:/ITTEC/SAM/Dev/SistemaMantenimiento/sistema-mantenimiento-back/public/public_files/';    // API JEAN
        } else {
            $filePath = 'C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\public_files\\';     // API QA
        }

        $fileName = $nuli.'-'.$como.'-'.$cldo.'-'.$fecr.'-'.$nuse.'='.$nuve.'='.$noar.'.'.$exte;
        
        $tempFile = $filePath . $fileName;

        $dompdf = new Dompdf();
        $dompdf ->loadHtml($html);
        $dompdf->setPaper('A4', 'portrait');
        $dompdf->render();


        $output = $dompdf->output();
        file_put_contents($tempFile, $output);
        $ubic = Storage::putFile('files', new File($tempFile));

        $ubic = str_replace("/", "\\", $ubic);
        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $ubic = "C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\storage\app\\" . $ubic;
        } else {
            $ubic = "C:\ITTEC\SAM\Dev\SistemaMantenimiento\sistema-mantenimiento-back\storage\app\\" . $ubic;
        }
        $tama = filesize($ubic);
        $usac = json_encode([$user]);

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

        try {
            $validateInsert = DB::table('S002V01TAFAL')->insert([
                'AFAL_NULI' => $line,
                'AFAL_COMO' => $como,
                'AFAL_CLDO' => $cldo,
                'AFAL_FECR' => $fecr,
                'AFAL_NUSE' => $nuse,
                'AFAL_NUVE' => $nuve,
                'AFAL_NOAR' => $noar,
                'AFAL_EXTE' => $exte,
                'AFAL_TAMA' => $tama,
                'AFAL_UBIC' => $ubic,
                'AFAL_USAC' => $usac,
                'AFAL_USRE' => $user,
                'AFAL_FERE' => $currentDate,
            ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEPDF005: Ocurrió un error guardar los datos a la tabla final de archivos.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$validateInsert ) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_FAILURELOG_GENERATEPDF006: No se pudo guardar la ficha del proveedor en la base de datos.", 
                [], 
                500
            );
        }

        if ($_SERVER['SERVER_NAME'] === '192.168.100.105') {
            $urlPublic = 'http://192.168.100.105:8000/public_files/' . $fileName;
        } else {
            $urlPublic = $this->functionsController->getApiURI().'sam/public_files/' . $fileName;
        }

        return $this->responseController->makeResponse(false, "EXITO: Modificación Exitosa", [ 'url' => $urlPublic ]);


    }
    public function registerFailureLog(Request $request) {
        $validator = Validator::make($request->all(), [
            'CODIGO_EQUIPAMIENTO' => 'required|string',
            'ID_FALLA' => 'required|integer',
            // 'ID_SINTOMA' => 'required|integer',
            'FECHA_FALLA' => 'required|string',
            'REPARABLE' => 'required|string',
            'SOLUCION' => 'required|string',
            'COMENTARIOS' => 'required|string',
            'VALOR_OBTENIDO' => 'required|string',
            'ID_MEDIDA' => 'required|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_FAILURELOG_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

        try {
            $validateExistsFailureList = DB::table('S002V01TLIFA')
                ->where('LIFA_NULI',  '=', $requestData['NUMERO_LINEA'])
                ->where('LIFA_IDFA',  '=', $requestData['ID_FALLA'])
                ->where('LIFA_ESTA',  '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG002: Ocurrió un error al consultar la lista de fallas.", $th->getMessage(), 500);
        }
        if ( !$validateExistsFailureList ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG003: No existe la falla #".$requestData['ID_FALLA']." en la lista de fallas.", [], 500);
        }

        if ( !is_null($requestData['ID_SINTOMA']) && $requestData['ID_SINTOMA'] !== '' ) {
            try {
                $validateExistsSymptomList = DB::table('S002V01TLISI')
                    ->where('LISI_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('LISI_IDSI', '=', $requestData['ID_SINTOMA'])
                    ->where('LISI_ESTA', '=', 'Activo')
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG004: Ocurrió un error al consultar la lista de síntomas.", $th->getMessage(), 500);
            }
            if ( !$validateExistsSymptomList ) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG005: No existe el síntoma #".$requestData['ID_SINTOMA']." en la lista de síntomas.", [], 500);
            }
        }

        try {
            $validateExistsMeasure = DB::table('S002V01TLIME')
                ->where('LIME_NULI',  '=', $requestData['NUMERO_LINEA'])
                ->where('LIME_IDME',  '=', $requestData['ID_MEDIDA'])
                ->where('LIME_ESTA',  '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG006: Ocurrió un error al consultar la lista de medidas.", $th->getMessage(), 500);
        }
        if ( !$validateExistsMeasure ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG007: No existe la medida #".$requestData['ID_MEDIDA']." en la lista de medidas.", [], 500);
        }

        try {
            $validateExistsEquipment = DB::table('S002V01TEQUI')
                ->where('EQUI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EQUI_COEQ', '=', $requestData['CODIGO_EQUIPAMIENTO'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG008: Ocurrió un error al consultar los equipamientos.", $th->getMessage(), 500);
        }
        if ( !$validateExistsEquipment ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG009: No existe el equipamiento ".$requestData['CODIGO_EQUIPAMIENTO']." en la lista de equipamientos.", [], 500);
        }

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

        try {
            $validateInsert = DB::table('S002V01TBIFA')->insert([
                'BIFA_NULI' => $requestData['NUMERO_LINEA'],
                'BIFA_COEQ' => $requestData['CODIGO_EQUIPAMIENTO'],
                'BIFA_IDFA' => $requestData['ID_FALLA'],
                'BIFA_IDSI' => $requestData['ID_SINTOMA'],
                'BIFA_FEFA' => $requestData['FECHA_FALLA'],
                'BIFA_REPA' => $requestData['REPARABLE'],
                'BIFA_DESO' => $requestData['SOLUCION'],
                'BIFA_COME' => $requestData['COMENTARIOS'],
                'BIFA_VAOB' => $requestData['VALOR_OBTENIDO'],
                'BIFA_IDME' => $requestData['ID_MEDIDA'],
                'BIFA_USRE' => $user,
                'BIFA_FERE' => $currentDate,
                'BIFA_FEAR' => DB::raw('CURRENT_TIMESTAMP')
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG010: Ocurrió un error al intentar registrar la falla en la base de datos.", $th->getMessage(), 500);
        }
        if ( !$validateInsert ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_REG011: No se pudo registrar la falla.", [], 500);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateFailureLog(Request $request) {
        $validator = Validator::make($request->all(), [
            'NUMERO_FALLA' => 'required|integer',
            'CODIGO_EQUIPAMIENTO' => 'required|string',
            'ID_FALLA' => 'required|integer',
            // 'ID_SINTOMA' => 'required|integer',
            'FECHA_FALLA' => 'required|string',
            'REPARABLE' => 'required|string',
            'SOLUCION' => 'required|string',
            'COMENTARIOS' => 'required|string',
            'VALOR_OBTENIDO' => 'required|string',
            'ID_MEDIDA' => 'required|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_FAILURELOG_UPD000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

        try {
            $validateExistsFailureLog = DB::table('S002V01TBIFA')
                ->where('BIFA_NULI',  '=', $requestData['NUMERO_LINEA'])
                ->where('BIFA_NUFA',  '=', $requestData['NUMERO_FALLA'])
                ->where('BIFA_ESTA',  '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD002: Ocurrió un error al consultar la bitácora de fallas.", $th->getMessage(), 500);
        }
        if ( !$validateExistsFailureLog ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD003: No existe la falla #".$requestData['NUMERO_FALLA']." en la bitácora de fallas.", [], 500);
        }

        try {
            $validateExistsFailureList = DB::table('S002V01TLIFA')
                ->where('LIFA_NULI',  '=', $requestData['NUMERO_LINEA'])
                ->where('LIFA_IDFA',  '=', $requestData['ID_FALLA'])
                ->where('LIFA_ESTA',  '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD004: Ocurrió un error al consultar la lista de fallas.", $th->getMessage(), 500);
        }
        if ( !$validateExistsFailureList ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD005: No existe la falla #".$requestData['ID_FALLA']." en la lista de fallas.", [], 500);
        }

        if ( !is_null($requestData['ID_SINTOMA']) && $requestData['ID_SINTOMA'] !== '' ) {
            try {
                $validateExistsSymptomList = DB::table('S002V01TLISI')
                    ->where('LISI_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('LISI_IDSI', '=', $requestData['ID_SINTOMA'])
                    ->where('LISI_ESTA', '=', 'Activo')
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD006: Ocurrió un error al consultar la lista de síntomas.", $th->getMessage(), 500);
            }
            if ( !$validateExistsSymptomList ) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD007: No existe el síntoma #".$requestData['ID_SINTOMA']." en la lista de síntomas.", [], 500);
            }
        }

        try {
            $validateExistsMeasure = DB::table('S002V01TLIME')
                ->where('LIME_NULI',  '=', $requestData['NUMERO_LINEA'])
                ->where('LIME_IDME',  '=', $requestData['ID_MEDIDA'])
                ->where('LIME_ESTA',  '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD008: Ocurrió un error al consultar la lista de medidas.", $th->getMessage(), 500);
        }
        if ( !$validateExistsMeasure ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD009: No existe la medida #".$requestData['ID_MEDIDA']." en la lista de medidas.", [], 500);
        }

        try {
            $validateExistsEquipment = DB::table('S002V01TEQUI')
                ->where('EQUI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('EQUI_COEQ', '=', $requestData['CODIGO_EQUIPAMIENTO'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD010: Ocurrió un error al consultar los equipamientos.", $th->getMessage(), 500);
        }
        if ( !$validateExistsEquipment ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD011: No existe el equipamiento ".$requestData['CODIGO_EQUIPAMIENTO']." en la lista de equipamientos.", [], 500);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TBIFA')
                ->where('BIFA_NUFA', '=', $requestData['NUMERO_FALLA'])
                ->where('BIFA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'BIFA_COEQ' => $requestData['CODIGO_EQUIPAMIENTO'],
                    'BIFA_IDFA' => $requestData['ID_FALLA'],
                    'BIFA_IDSI' => $requestData['ID_SINTOMA'],
                    'BIFA_FEFA' => $requestData['FECHA_FALLA'],
                    'BIFA_REPA' => $requestData['REPARABLE'],
                    'BIFA_DESO' => $requestData['SOLUCION'],
                    'BIFA_COME' => $requestData['COMENTARIOS'],
                    'BIFA_VAOB' => $requestData['VALOR_OBTENIDO'],
                    'BIFA_IDME' => $requestData['ID_MEDIDA'],
                    'BIFA_USMO' => $user,
                    'BIFA_FEMO' => $currentDate,
                    'BIFA_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD012: Ocurrió un error al intentar modificar la falla en la base de datos.", $th->getMessage(), 500);
        }
        if ( !$validateUpdate ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_FAILURELOG_UPD013: No se pudo modificar la bitácora de falla.", [], 500);
        }

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



    public function getSymptoms($user, $line) {

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

        try {
            $getSymptom = DB::table('S002V01TLISI')
                ->where('LISI_NULI', '=', $line)
                ->where('LIME_NULI', '=', $line)
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'LISI_IDME')
                ->get([
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION',
                    'LISI_CAUS AS CAUSA',
                    'LISI_DESC AS DESCRIPCION',
                    'LISI_SOLU AS SOLUCION',
                    'LISI_LIVA AS LIMITE_VALOR',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'LISI_ESTA AS ESTADO',
                    'LISI_USRE AS USUARIO_REGISTRA',
                    'LISI_FERE AS FECHA_REGISTRA',
                    'LISI_USMO AS USUARIO_MODIFICA',
                    'LISI_FEMO AS FECHA_MODIFICA',
                ]);
            $arrSymtoms = json_decode( json_encode($getSymptom), true );
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_GET000: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }

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

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrSymtoms);
    }
    public function getSymptomsActives($user, $line) {
        try {
            $getSymptom = DB::table('S002V01TLISI')
                ->where('LISI_NULI', '=', $line)
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_NULI', '=', $line)
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'LISI_IDME')
                ->get([
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION',
                    'LISI_CAUS AS CAUSA',
                    'LISI_DESC AS DESCRIPCION',
                    'LISI_SOLU AS SOLUCION',
                    'LISI_LIVA AS LIMITE_VALOR',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'LISI_ESTA AS ESTADO',
                    'LISI_USRE AS USUARIO_REGISTRA',
                    'LISI_FERE AS FECHA_REGISTRA',
                    'LISI_USMO AS USUARIO_MODIFICA',
                    'LISI_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_GETACTIVE000: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }

        $arrSymtoms = json_decode( json_encode($getSymptom), true );
        
        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrSymtoms);
    }
    public function getSymptomsByEquipment($equipment, $user, $line) {
        try {
            $equipment = $this->encController->decrypt($equipment);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_GETBYEQUIPMENT000: No se pudo obtener el equipamiento.", $th->getMessage(), 500);
        }

        try {
            $getSymptom = DB::table('S002V01TLSEQ')
                ->where('LSEQ_NULI', '=', $line)
                ->where('LSEQ_ESTA', '=', 'Activo')
                ->where('LSEQ_COEQ', '=', $equipment)
                ->where('LISI_NULI', '=', $line)
                ->where('LISI_ESTA', '=', 'Activo')
                ->join('S002V01TLISI', 'LISI_IDSI', '=', 'LSEQ_IDSI')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'LISI_IDME')
                ->get([
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION',
                    'LISI_CAUS AS CAUSA',
                    'LISI_DESC AS DESCRIPCION',
                    'LISI_SOLU AS SOLUCION',
                    'LISI_LIVA AS LIMITE_VALOR',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'LISI_ESTA AS ESTADO',
                    'LISI_USRE AS USUARIO_REGISTRA',
                    'LISI_FERE AS FECHA_REGISTRA',
                    'LISI_USMO AS USUARIO_MODIFICA',
                    'LISI_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_GETBYEQUIPMENT001: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }

        $arrSymtoms = json_decode( json_encode($getSymptom), true );
        
        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrSymtoms);
    }
    public function getSymptomById($idSymptom, $user, $line) {

        try {
            $idSymptom = $this->encController->decrypt($idSymptom);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_GETBYID000: No se pudo obtener el ID del síntoma.", $th->getMessage(), 500);
        }

        try {
            $arrSymptom = (array) DB::table('S002V01TLISI')
                ->where('LISI_IDSI', '=', $idSymptom)
                ->where('LISI_NULI', '=', $line)
                ->where('LISI_ESTA', '=', 'Activo')
                ->where('LIME_NULI', '=', $line)
                ->where('LIME_ESTA', '=', 'Activo')
                ->join('S002V01TLIME', 'LIME_IDME', '=', 'LISI_IDME')
                ->first([
                    'LISI_IDSI AS ID_SINTOMA',
                    'LISI_NOSI AS NOMBRE_SINTOMA',
                    'LISI_CLAS AS CLASIFICACION',
                    'LISI_CAUS AS CAUSA',
                    'LISI_DESC AS DESCRIPCION',
                    'LISI_SOLU AS SOLUCION',
                    'LISI_LIVA AS LIMITE_VALOR',
                    'LIME_IDME AS ID_MEDIDA',
                    'LIME_NOME AS NOMBRE_MEDIDA',
                    'LIME_ACME AS ACRONIMO_MEDIDA',
                    'LISI_ESTA AS ESTADO',
                    'LISI_USRE AS USUARIO_REGISTRA',
                    'LISI_FERE AS FECHA_REGISTRA',
                    'LISI_USMO AS USUARIO_MODIFICA',
                    'LISI_FEMO AS FECHA_MODIFICA',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_GETBYID001: No se pudo realizar la consulta a la base.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !empty($arrSymptom) ) {
            try {
                $arrEquipment = DB::table('S002V01TLSEQ')
                    ->where('LSEQ_IDSI', '=', $idSymptom)
                    ->where('LSEQ_NULI', '=', $line)
                    ->where('LSEQ_ESTA', '=', 'Activo')
                    ->where('EQUI_NULI', '=', $line)
                    ->join('S002V01TEQUI', 'EQUI_COEQ', '=', 'LSEQ_COEQ')
                    ->get([
                        'EQUI_COEQ AS CODIGO',
                        'EQUI_TIPO AS TIPO',
                        'EQUI_MODE AS MODELO',
                        'EQUI_IDEQ AS ID_EQUIPO',
                        'EQUI_ESFU AS ESTADO_FUNCIONAMIENTO',
                        'EQUI_ELOR AS ELEMENTO_ORIGEN',
                        'EQUI_TICO AS TIPO_CODIGO'
                    ]);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_GETBYID002: No se pudo realizar la consulta a la base.", 
                    $th->getMessage(), 
                    500
                );
            }

            $arrEquipment = json_decode( json_encode($arrEquipment), true );

            foreach ($arrEquipment as $keyEquipment => $equipment) {
                $equipment['ID_EQUIPO'] = strval($equipment['ID_EQUIPO']);
                $arrEquipment[$keyEquipment] = $equipment;
            }
            $arrSymptom['EQUIPAMIENTOS'] = $arrEquipment;


            try {
                $arrFailure = DB::table('S002V01TLFLS')
                    ->where('LFLS_IDSI', '=', $idSymptom)
                    ->where('LFLS_NULI', '=', $line)
                    ->where('LFLS_ESTA', '=', 'Activo')
                    ->where('LIFA_NULI', '=', $line)
                    ->where('LIFA_ESTA', '=', 'Activo')
                    ->join('S002V01TLIFA', 'LIFA_IDFA', '=', 'LFLS_IDFA')
                    ->get([
                        'LIFA_IDFA AS ID_FALLA',
                        'LIFA_NOFA AS NOMBRE_FALLA',
                        'LIFA_NIVE AS NIVEL_CRITICIDAD',
                        'LIFA_CAUS AS CAUSA_FALLA',
                        'LIFA_SOLU AS SOLICION',
                        'LIFA_DESC AS DESCRIPCION',
                    ]);
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_GETBYID003: No se pudo realizar la consulta a la base.", 
                    $th->getMessage(), 
                    500
                );
            }
            $arrFailure = json_decode( json_encode($arrFailure), true );

            $arrSymptom['FALLAS'] = $arrFailure;
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrSymptom);
    }
    public function registerSymptom(Request $request) {
        $validator = Validator::make($request->all(), [
            'NOMBRE_SINTOMA' => 'required|string',
            'CLASIFICACION' => 'required|string',
            'CAUSA' => 'required|string', 
            'DESCRIPCION' => 'required|string', 
            'SOLUCION' => 'required|string', 
            'LIMITE_VALOR' => 'required|string', 
            'ID_MEDIDA' => 'required|string', 
            'FALLAS' => 'required|array', 
            'EQUIPAMIENTOS' => 'required|array',
            'USUARIO' => 'required|string', 
            'NUMERO_LINEA' => 'required|integer', 

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

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_REG001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

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

        try {
            $idSymptom = DB::table('S002V01TLISI')->insertGetId([
                'LISI_NULI' => $requestData['NUMERO_LINEA'],
                'LISI_NOSI' => $requestData['NOMBRE_SINTOMA'],
                'LISI_CLAS' => $requestData['CLASIFICACION'],
                'LISI_CAUS' => $requestData['CAUSA'],
                'LISI_SOLU' => $requestData['SOLUCION'],
                'LISI_DESC' => $requestData['DESCRIPCION'],
                'LISI_LIVA' => $requestData['LIMITE_VALOR'],
                'LISI_IDME' => $requestData['ID_MEDIDA'],
                'LISI_USRE' => $user,
                'LISI_FERE' => $currentDate,
                'LISI_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_REG002: Ocurrió un error en el registro de la lista de síntoma en la base de datos.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$idSymptom ) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_REG003: No se pudo hacer el registro de la lista de síntoma en la base de datos.", 
                [], 
                500
            );
        }

        foreach ($requestData['EQUIPAMIENTOS'] as $keyEquipment => $equipment) {
            try {
                $validateRegisterEquipment = DB::table('S002V01TLSEQ')->insert([
                    'LSEQ_NULI' => $requestData['NUMERO_LINEA'],
                    'LSEQ_IDSI' => $idSymptom,
                    'LSEQ_COEQ' => $equipment,
                    'LSEQ_USRE' => $user,
                    'LSEQ_FERE' => $currentDate,
                    'LSEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse( 
                    true, 
                    "ERR_SYMPTOM_REG004: Ocurrió un error al registrar el formulario en la lista de síntomas.", 
                    $th->getMessage(), 
                    500
                );
            }

            if ( !$validateRegisterEquipment ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_REG005: No se pudo registrar el equipamiento $equipment en la lista de síntomas.", 
                    [], 
                    500
                );
            }
        }

        foreach ($requestData['FALLAS'] as $keyFailure => $failure) {
            try {
                $validateRegisterFailure = DB::table('S002V01TLFLS')->insert([
                    'LFLS_NULI' => $requestData['NUMERO_LINEA'],
                    'LFLS_IDFA' => $failure,
                    'LFLS_IDSI' => $idSymptom,
                    'LFLS_USRE' => $user,
                    'LFLS_FERE' => $currentDate,
                    'LFLS_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse( 
                    true, 
                    "ERR_SYMPTOM_REG006: Ocurrió un error al registrar el formulario en la lista de síntomas.", 
                    $th->getMessage(), 
                    500
                );
            }

            if ( !$validateRegisterFailure ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_REG007: No se pudo registrar el equipamiento $equipment en la lista de síntomas.", 
                    [], 
                    500
                );
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateSymptom(Request $request) {
        $validator = Validator::make($request->all(), [
            'ID_SINTOMA' => 'required|integer',
            'NOMBRE_SINTOMA' => 'required|string',
            'CLASIFICACION' => 'required|string',
            'CAUSA' => 'required|string', 
            'DESCRIPCION' => 'required|string', 
            'SOLUCION' => 'required|string', 
            'LIMITE_VALOR' => 'required|string', 
            'ID_MEDIDA' => 'required|string', 
            'FALLAS' => 'required|array', 
            'EQUIPAMIENTOS' => 'required|array',
            'USUARIO' => 'required|string', 
            'NUMERO_LINEA' => 'required|integer', 

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

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_UPD001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TLISI')
                ->where('LISI_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LISI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LISI_NOSI' => $requestData['NOMBRE_SINTOMA'],
                    'LISI_CLAS' => $requestData['CLASIFICACION'],
                    'LISI_CAUS' => $requestData['CAUSA'],
                    'LISI_SOLU' => $requestData['SOLUCION'],
                    'LISI_DESC' => $requestData['DESCRIPCION'],
                    'LISI_LIVA' => $requestData['LIMITE_VALOR'],
                    'LISI_IDME' => $requestData['ID_MEDIDA'],
                    'LISI_USMO' => $user,
                    'LISI_FEMO' => $currentDate,
                    'LISI_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_UPD002: Ocurrió un error en el registro de la lista de síntoma en la base de datos.", 
                $th->getMessage(), 
                500
            );
        }

        if ( !$validateUpdate ) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_UPD003: Ocurrió un error en la modificación de la lista de síntoma en la base de datos.", 
                [], 
                500
            );
        }

        foreach ($requestData['EQUIPAMIENTOS'] as $keyEquipment => $equipment) {
            try {
                $validateExists = DB::table('S002V01TLSEQ')
                    ->where('LSEQ_IDSI', '=', $requestData['ID_SINTOMA'])
                    ->where('LSEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('LSEQ_COEQ', '=', $equipment)
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_UPD004: Ocurrió un error al consultar el equipamiento.", 
                    $th->getMessage(), 
                    500
                );
            }
    
            if ( $validateExists ) {
                try {
                    $validate = DB::table('S002V01TLSEQ')
                        ->where('LSEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('LSEQ_IDSI', '=', $requestData['ID_SINTOMA'])
                        ->where('LSEQ_COEQ', '=', $equipment)
                        ->update([
                            'LSEQ_ESTA' => 'Activo',
                            'LSEQ_USMO' => $user,
                            'LSEQ_FEMO' => $currentDate,
                            'LSEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD005: Ocurrió un error al modificar el formulario en la lista de falla el equipamiento $equipment.", 
                        $th->getMessage(), 
                        500
                    );
                }
            } else {
                try {
                    $validate = DB::table('S002V01TLSEQ')->insert([
                        'LSEQ_NULI' => $requestData['NUMERO_LINEA'],
                        'LSEQ_IDSI' => $requestData['ID_SINTOMA'],
                        'LSEQ_COEQ' => $equipment,
                        'LSEQ_USRE' => $user,
                        'LSEQ_FERE' => $currentDate,
                        'LSEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD006: Ocurrió un error al registrar el formulario en la lista de falla el equipamiento $equipment.", 
                        $th->getMessage(), 
                        500
                    );
                }
            }
            if ( !$validate ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_UPD007: No se pudo modificar el equipamiento $equipment en la lista de fallas.", 
                    [], 
                    500
                );
            }
        }

        try {
            $getListEquipment = DB::table('S002V01TLSEQ')
                ->where('LSEQ_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LSEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                ->get([
                    'LSEQ_IDLS',
                    'LSEQ_IDSI',
                    'LSEQ_COEQ',
                    'LSEQ_ESTA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_UPD008: Ocurrió un error al consultar la lista de equipamientos.", 
                $th->getMessage(), 
                500
            );
        }

        $arrListEquipment = json_decode( json_encode($getListEquipment), true );
        
        foreach ($arrListEquipment as $keyListEquipment => $listEquipment) {
            if( !in_array($listEquipment['LSEQ_COEQ'], $requestData['EQUIPAMIENTOS']) ) {
                try {
                    $validateDelete = DB::table('S002V01TLSEQ')
                        ->where('LSEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('LSEQ_IDSI', '=', $requestData['ID_SINTOMA'])
                        ->where('LSEQ_COEQ', '=', $listEquipment['LSEQ_COEQ'])
                        ->update([
                            'LSEQ_ESTA' => 'Eliminado',
                            'LSEQ_USMO' => $user,
                            'LSEQ_FEMO' => $currentDate,
                            'LSEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD009: Ocurrió un error al eliminar de la lista de falla el equipamiento ". $listEquipment['LSEQ_COEQ'].".", 
                        $th->getMessage(), 
                        500
                    );
                }

                if ( !$validateDelete ) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD010: No se pudo eliminar de la lista de falla el equipamiento ". $listEquipment['LFEQ_COEQ'].".", 
                        [], 
                        500
                    );
                }
            }
        }

        foreach ($requestData['FALLAS'] as $keyFailure => $failure) {
            try {
                $validateExists = DB::table('S002V01TLFLS')
                    ->where('LFLS_IDFA', '=', $failure)
                    ->where('LFLS_IDSI', '=', $requestData['ID_SINTOMA'])
                    ->where('LFLS_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_UPD011: Ocurrió un error al consultar la falla.", 
                    $th->getMessage(), 
                    500
                );
            }

            if ( $validateExists ) {
                try {
                    $validate = DB::table('S002V01TLFLS')
                        ->where('LFLS_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->where('LFLS_IDFA', '=', $failure)
                        ->where('LFLS_IDSI', '=', $requestData['ID_SINTOMA'])
                        ->update([
                            'LFLS_ESTA' => 'Activo',
                            'LFLS_USMO' => $user,
                            'LFLS_FEMO' => $currentDate,
                            'LFLS_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD012: Ocurrió un error al modificar el formulario en la lista de falla del síntoma.", 
                        $th->getMessage(), 
                        500
                    );
                }
            } else {
                try {
                    $validate = DB::table('S002V01TLFLS')->insert([
                        'LFLS_NULI' => $requestData['NUMERO_LINEA'],
                        'LFLS_IDSI' => $requestData['ID_SINTOMA'],
                        'LFLS_IDFA' => $failure,
                        'LFLS_USRE' => $user,
                        'LFLS_FERE' => $currentDate,
                        'LFLS_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD013: Ocurrió un error al registrar el formulario en la lista de falla del síntoma.", 
                        $th->getMessage(), 
                        500
                    );
                }
            }
            if ( !$validate ) {
                DB::rollBack();
                return $this->responseController->makeResponse(
                    true, 
                    "ERR_SYMPTOM_UPD014: No se pudo modificar la lista de fallas.", 
                    [], 
                    500
                );
            }
        }

        try {
            $arrListFaliure = DB::table('S002V01TLFLS')
                ->where('LFLS_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LFLS_NULI', '=', $requestData['NUMERO_LINEA'])
                ->get([
                    'LFLS_IDFA',
                    'LFLS_IDSI',
                    'LFLS_ESTA',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_UPD015: Ocurrió un error al consultar la lista de fallas del síntoma.", 
                $th->getMessage(), 
                500
            );
        }

        $arrListFaliure = json_decode( json_encode($arrListFaliure), true );
        
        foreach ($arrListFaliure as $keyListFaliure => $listFaliure) {
            if( !in_array($listFaliure['LFLS_IDFA'], $requestData['FALLAS']) ) {
                try {
                    $validateDelete = DB::table('S002V01TLFLS')
                        ->where('LFLS_IDFA', '=', $listFaliure['LFLS_IDFA'])
                        ->where('LFLS_IDSI', '=', $requestData['ID_SINTOMA'])
                        ->where('LFLS_NULI', '=', $requestData['NUMERO_LINEA'])
                        ->update([
                            'LFLS_ESTA' => 'Eliminado',
                            'LFLS_USMO' => $user,
                            'LFLS_FEMO' => $currentDate,
                            'LFLS_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                        ]);
                } catch (\Throwable $th) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD016: Ocurrió un error al eliminar las falla ".$listFaliure['LFLS_IDFA']." del síntoma.", 
                        $th->getMessage(), 
                        500
                    );
                }

                if ( !$validateDelete ) {
                    DB::rollBack();
                    return $this->responseController->makeResponse( 
                        true, 
                        "ERR_SYMPTOM_UPD017: No se pudo eliminar la falla ".$listFaliure['LFLS_IDFA']." del síntoma.", 
                        [], 
                        500
                    );
                }
            }
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Modificación Exitosa");
    }
    public function deleteSymptom(Request $request) {
        $validator = Validator::make($request->all(), [
            'ID_SINTOMA' => 'required|string',
            'NUMERO_LINEA' => 'required|integer',
            'USUARIO' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_SYMPTOM_DEL000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $user = $this->encController->decrypt($requestData['USUARIO']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL001: No se pudo obtener el usuario.", $th->getMessage(), 500);
        }

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

        try {
            $exist = DB::table('S002V01TLISI')
                ->where('LISI_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LISI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL002: Ocurrió un error al consultar en la base de datos.", $th->getMessage(), 500);
        }
        
        if (!$exist) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL003: El archivo no existe.", [], 500);
        }

        try {
            $validateDelete = DB::table('S002V01TLISI')
                ->where('LISI_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LISI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LISI_ESTA' => 'Eliminado',
                    'LISI_USMO' => $user,
                    'LISI_FEMO' => $currentDate,
                    'LISI_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL004: Ocurrió un error al eliminar el síntoma de la base de datos.", $th->getMessage(), 500);
        }
        if ( !$validateDelete ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL005: No se pudo eliminar el síntoma de la base de datos.", [], 500);
        }


        try {
            $validateDelete = DB::table('S002V01TLSEQ')
                ->where('LSEQ_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LSEQ_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LSEQ_ESTA' => 'Eliminado',
                    'LSEQ_USMO' => $user,
                    'LSEQ_FEMO' => $currentDate,
                    'LSEQ_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_DEL006: Ocurrió un error al eliminar la lista de equipamientos.", 
                $th->getMessage(), 
                500
            );
        }
        if ( !$validateDelete ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL007: No se pudo eliminar la lista de equipamientos.", [], 500);
        }

        try {
            $validateDelete = DB::table('S002V01TLFLS')
                ->where('LFLS_IDSI', '=', $requestData['ID_SINTOMA'])
                ->where('LFLS_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'LFLS_ESTA' => 'Eliminado',
                    'LFLS_USMO' => $user,
                    'LFLS_FEMO' => $currentDate,
                    'LFLS_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_SYMPTOM_DEL008: Ocurrió un error al eliminar la lista de fallas.", 
                $th->getMessage(), 
                500
            );
        }
        if ( !$validateDelete ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_SYMPTOM_DEL009: No se pudo eliminar la lista de fallas.", [], 500);
        }
        
        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Eliminación Exitosa");
    }


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

        $requestData = $request->all();

        try {
            $equipment = (array) DB::table('S002V01TEQUI')
                ->where([
                    ['EQUI_COEQ', '=', $requestData['CODIGO_EQUIPAMIENTO']],
                    ['EQUI_NULI', '=', $requestData['NUMERO_LINEA']],
                ])
                ->first([
                    'EQUI_HICO AS HISTORIAL'
                ]);
        } catch (\Throwable $th) {
            return $th;
        }

        $currentCode = $requestData['CODIGO_EQUIPAMIENTO'];
        $pbs = explode('_', $currentCode)[1];
        $status = explode('.', $pbs)[2];

        $arrRangeDateOn = array();
        $arrRangeDateOff = array();
        $arrHistory = json_decode($equipment['HISTORIAL'], true);
        $isInitOn = true;
        $isInitOff = true;
        $indexOn = 0;
        $indexOff = 0;
        foreach ($arrHistory as $keyHistory => $history) {
            $pbs = explode('_', $history['CODIGO'])[1];
            $status = explode('.', $pbs)[2];
            
            if ($isInitOn && $status === 'I') {
                $arrRangeDateOn[$indexOn]['INITIAL'] = $history['FECHA'];
                $isInitOn = false;
            }
            if (!$isInitOn && $status !== 'I') {
                $arrRangeDateOn[$indexOn]['FINAL'] = $history['FECHA'];
                $isInitOn = true;
                $indexOn++;
            }


            if ($isInitOff && $status !== 'I') {
                $arrRangeDateOff[$indexOff]['INITIAL'] = $history['FECHA'];
                $isInitOff = false;
            }
            if (!$isInitOff && $status === 'I') {
                $arrRangeDateOff[$indexOff]['FINAL'] = $history['FECHA'];
                $isInitOff = true;
                $indexOff++;
            }
        }

        $lastIndex = count($arrRangeDateOn)-1;
        if (!array_key_exists('FINAL', $arrRangeDateOn[$lastIndex])) {
            $now = $this->functionsController->now();
            $currentDate = $now->toDateTimeString();
            $arrRangeDateOn[$lastIndex]['FINAL'] = $currentDate;
        }


        $rangeInitial = Carbon::parse($requestData['FECHA_INICIO']);
        $rangeFinal = Carbon::parse($requestData['FECHA_FINAL']);

        $activeHours = 0;
        foreach ($arrRangeDateOn as $key => $range) {
            $dateInitial = Carbon::parse($range['INITIAL']);
            $dateFinal = Carbon::parse($range['FINAL']);
            

            if ($dateInitial->gte($rangeInitial) && $dateFinal->lte($rangeFinal)) {
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $activeHours += $diffHours;
            } else if ($dateInitial->gte($rangeInitial) && $dateFinal->gte($rangeFinal) ) {
                $dateFinal = $rangeFinal;
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $activeHours += $diffHours;
            } else if ($dateInitial->lte($rangeInitial) && $dateFinal->lte($rangeFinal) ) {
                $dateInitial = $rangeInitial;
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $activeHours += $diffHours;
            }
        }


        $inactiveHours = 0;
        foreach ($arrRangeDateOff as $key => $range) {
            $dateInitial = Carbon::parse($range['INITIAL']);
            $dateFinal = Carbon::parse($range['FINAL']);
            

            if ($dateInitial->gte($rangeInitial) && $dateFinal->lte($rangeFinal)) {
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $inactiveHours += $diffHours;
            } else if ($dateInitial->gte($rangeInitial) && $dateFinal->gte($rangeFinal) ) {
                $dateFinal = $rangeFinal;
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $inactiveHours += $diffHours;
            } else if ($dateInitial->lte($rangeInitial) && $dateFinal->lte($rangeFinal) ) {
                $dateInitial = $rangeInitial;
                $diffHours = $dateInitial->diffInHours($dateFinal);
                $inactiveHours += $diffHours;
            }
        }



        try {
            $countPrev = DB::table('S002V01TOTPR')
                ->where([
                    ['OTPR_EQIN', '=', $requestData['CODIGO_EQUIPAMIENTO']],
                    ['OTPR_NULI', '=', $requestData['NUMERO_LINEA']],
                ])
                ->count();
        } catch (\Throwable $th) {
            return $th;
        }

        try {
            $countCorr = DB::table('S002V01TOTCO')
                ->where([
                    ['OTCO_EQIN', '=', $requestData['CODIGO_EQUIPAMIENTO']],
                    ['OTCO_NULI', '=', $requestData['NUMERO_LINEA']],
                ])
                ->count();
        } catch (\Throwable $th) {
            return $th;
        }


        $MTBF = $activeHours / $countCorr;

        $response = [
            'HORAS_FUNCIONAMIENTO' => $activeHours,
            'CANTIDAD_MANTENIMIENTO_PREVENTIVO' => $countPrev,
            'CANTIDAD_FALLAS_TOTALES' => $countCorr,
            'HORAS_INACTIVIDAD' => $inactiveHours,
            'MTBF' => $MTBF,
        ];

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