<?php
/*
    Desarrollador: Ing. Jean Jairo Benitez Meza
    Ultima Modificación: 11/04/2023
    Módulo: Gestión de Inventario y/o Stock
*/
namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Http\Controllers\ResourcesController;
use App\Http\Controllers\ResponseController;
use App\Http\Controllers\EncryptionController;
use App\Http\Controllers\DocumentManagementController;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use App\Http\Controllers\FunctionsController;

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

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

    // Crear Artículo en Stock
    public function createArtitleWithoutOrder(Request $request) {
        $validator = Validator::make($request->all(), [
            'ARTICULO' => 'required',
            'MODELO' => 'required',
            'CODIGO_MODELO' => 'required',
            'FAMILIA' => 'required',
            'SUBFAMILIA' => 'required',
            'UNIDAD' => 'required',
            'CODIGO_BARRAS' => 'required',
            'CANTIDAD' => 'required',
            'STOCK_MINIMO' => 'required',
            'STOCK_MAXIMO' => 'required',
            'REPARACION' => 'required|boolean',
            'CONSUMIBLE' => 'required|boolean',
            'PELIGROSO' => 'required|boolean',
            // 'FECHA_VENCIMIENTO' => '',
            // 'PROVEEDOR' => 'required',
            'IMAGEN' => 'required',
            'NUMERO_LINEA' => 'required',
            'USUARIO' => 'required',
        ]);

        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_STOCK_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_STOCK_REG001: Ocurrió un error al obtener el usuario.", $th->getMessage(), 500);
        }

        try {
            $validateFamily = DB::table('S002V01TFAMI')
                ->where('FAMI_COFA','=', $requestData['FAMILIA'])
                ->where('FAMI_NULI','=', $requestData['NUMERO_LINEA'])
                ->where('FAMI_ESTA','=','Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG002: Ocurrió un error al validar la familia.", $th->getMessage(), 500);
        }
        if (!$validateFamily) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG003: La familia no existe.", [], 500);
        }

        try {
            $validateSubfamily = DB::table('S002V01TSUBF')
                ->where('SUBF_COSU','=', $requestData['SUBFAMILIA'])
                ->where('SUBF_NULI','=', $requestData['NUMERO_LINEA'])
                ->where('SUBF_ESTA','=','Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG004: Ocurrió un error al validar la subfamilia.", $th->getMessage(), 500);
        }
        if (!$validateSubfamily) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG005: La subfamilia no existe.", [], 500);
        }
        
        try {
            $validateUnit = DB::table('S002V01TUNID')
                ->where('UNID_IDUN','=', $requestData['UNIDAD'])
                ->where('UNID_NULI','=', $requestData['NUMERO_LINEA'])
                ->where('UNID_ESTA','=','Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG006: Ocurrió un error al validar la unidad.", $th->getMessage(), 500);
        }
        if (!$validateUnit) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG007: La unidad no existe.", [], 500);
        }

        $requestData['PROVEEDOR'] = $requestData['PROVEEDOR'] === '' ? null : $requestData['PROVEEDOR'];

        if (!is_null($requestData['PROVEEDOR'])) {
            try {
                $validateUnit = DB::table('S002V01TPROV')
                    ->where('PROV_NUPR','=', $requestData['PROVEEDOR'])
                    ->where('PROV_NULI','=', $requestData['NUMERO_LINEA'])
                    ->where('PROV_ESTA','=','Activo')
                    ->exists();
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ERR_STOCK_REG008: Ocurrió un error al validar el proveedor.", $th->getMessage(), 500);
            }
            if (!$validateUnit) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, "ERR_STOCK_REG009: El proveedor no existe.", [], 500);
            }
        }
       

        $arrCodeImages = array();
        foreach ($requestData['IMAGEN'] as $key => $encIdFile) {

            $idFile = $this->encController->decrypt($encIdFile);
            $tempFile = DB::table('S002V01TARTE')->where([
                ['ARTE_NULI', '=', $requestData['NUMERO_LINEA']],
                ['ARTE_IDAR', '=', $idFile],
            ])->first();

            if(is_null($tempFile)){
                return $this->responseController->makeResponse(true, 'ERR_ARTITLE_REG006: El archivo consultado no está registrado', [], 404);
            }else if($tempFile->ARTE_ESTA == 'Eliminado'){
                return $this->responseController->makeResponse(true, 'ERR_ARTITLE_REG007: El archivo consultado está eliminado', [], 404);
            }
            $fileResponse = $this->documentManagementController->moveFinalFile(
                intval($requestData['NUMERO_LINEA']),
                'GIST',
                'FO',
                $tempFile,
                $user,
            );
            if(!$fileResponse[0]){
                return $this->responseController->makeResponse(true, 'ERR_ARTITLE_REG008: '.$fileResponse[1], [], 400);
            }
            $arrCodeImages[] = $this->encController->encrypt($fileResponse[1]);
        }
        $jsonImages = json_encode($arrCodeImages);

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

        try {
            $validateRegister = DB::table('S002V01TSTAR')->insert([
                // 'STAR_CODI' => $requestData['CODIGO_STOCK'],
                'STAR_ARTI' => $requestData['ARTICULO'],
                'STAR_MODE' => $requestData['MODELO'],
                'STAR_COMO' => $requestData['CODIGO_MODELO'],
                'STAR_IDFA' => $requestData['FAMILIA'],
                'STAR_IDSU' => $requestData['SUBFAMILIA'],
                'STAR_NUPR' => $requestData['PROVEEDOR'],
                'STAR_IDUN' => $requestData['UNIDAD'],
                'STAR_COBA' => $requestData['CODIGO_BARRAS'],
                'STAR_CANT' => $requestData['CANTIDAD'],
                'STAR_STMI' => $requestData['STOCK_MINIMO'],
                'STAR_STMA' => $requestData['STOCK_MAXIMO'],
                'STAR_REPA' => $requestData['REPARACION'],
                'STAR_CONS' => $requestData['CONSUMIBLE'],
                'STAR_PELI' => $requestData['PELIGROSO'],
                'STAR_FEVE' => $requestData['FECHA_VENCIMIENTO'],
                'STAR_IMAG' => $jsonImages,
                'STAR_TIAD' => 'Sin Pedido',
                'STAR_NULI' => $requestData['NUMERO_LINEA'],
                'STAR_USRE' => $user,
                'STAR_FERE' => $currentDate,
                'STAR_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG011: Ocurrió un error al registrar el artículo.", $th->getMessage(), 500);
        }

        if (!$validateRegister) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, "ERR_STOCK_REG012: No se pudo registrar el artículo.", [], 500);
        }

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

    // FUNCIÓN GESTIÓN DE ALMACENES
    public function getWarehouse( $user, $line ) {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_GETBY000:'.$arrResponseCheckUser['msg'], [], 401);
        }
        
        try {
            $arrWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $line)
                ->get([
                    'ALMA_COAL AS CODIGO_ALMACEN',
                    'ALMA_NOAL AS NOMBRE_ALMACEN',
                    'ALMA_NORE AS NOMBRE_RESPONSABLE',
                    'ALMA_APRE AS APELLIDO_PATERNO_RESPONSABLE',
                    'ALMA_AMRE AS APELLIDO_MATERNO_RESPONSABLE',
                    'ALMA_COR1 AS CORREO1',
                    'ALMA_COR2 AS CORREO2',
                    'ALMA_LAD1 AS LADA1',
                    'ALMA_TEL1 AS TELEFONO1',
                    'ALMA_LAD2 AS LADA2',
                    'ALMA_TEL2 AS TELEFONO2',
                    'ALMA_CALL AS CALLE',
                    'ALMA_NUEX AS NUMERO_EXTERIOR',
                    'ALMA_NUIN AS NUMERO_INTERIOR',
                    'ALMA_COPO AS CODIGO_POSTAL',
                    'ALMA_COLO AS COLONIA',
                    'ALMA_LOCA AS LOCALIDAD',
                    'ALMA_MUNI AS MUNICIPIO',
                    'ALMA_ENTI AS ENTIDAD_FEDERATIVA',
                    'ALMA_PAIS AS PAIS',
                    'ALMA_ESTA AS ESTADO',
                    'ALMA_USRE AS USUARIO_REGISTRA',
                    'ALMA_FERE AS FECHA_REGISTRA',
                    'ALMA_USMO AS USUARIO_MODIFICA',
                    'ALMA_FEMO AS FECHA_MODIFICA',
                ]);

            $arrWarehouse = json_decode( json_encode($arrWarehouse), true );
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_GET001: Ocurrió un error al obtener los almacenes.", 
                $th->getMessage(), 
                500
            );
        }

        foreach ($arrWarehouse as $keyWarehouse => $warehouse) {
            $arrResponseGetAddress = $this->resourcesController->getAddress(
                $warehouse['CODIGO_POSTAL'],
                $warehouse['COLONIA'],
                $warehouse['MUNICIPIO'],
                $warehouse['LOCALIDAD'],
                $warehouse['ENTIDAD_FEDERATIVA'],
                $warehouse['PAIS'],
                $line
            );
            if ($arrResponseGetAddress['error']) {
                return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_GET002: '.$arrResponseGetAddress['msg'], $arrResponseGetAddress['response'], 401);
            }

            $warehouse['CODIGO_POSTAL'] = $arrResponseGetAddress['response']['CODIGO_POSTAL'];
            $warehouse['COLONIA'] = $arrResponseGetAddress['response']['COLONIA'];
            $warehouse['MUNICIPIO'] = $arrResponseGetAddress['response']['MUNICIPIO'];
            $warehouse['LOCALIDAD'] = $arrResponseGetAddress['response']['LOCALIDAD'];
            $warehouse['ENTIDAD_FEDERATIVA'] = $arrResponseGetAddress['response']['ENTIDAD_FEDERATIVA'];
            $warehouse['PAIS'] = $arrResponseGetAddress['response']['PAIS'];

            $arrWarehouse[$keyWarehouse] = $warehouse;

        }

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

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

        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_GETBY000:'.$arrResponseCheckUser['msg'], [], 401);
        }
        
        try {
            $arrWarehouse = (array) DB::table('S002V01TALMA')
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->where('ALMA_NULI', '=', $line)
                ->first([
                    'ALMA_COAL AS CODIGO_ALMACEN',
                    'ALMA_NOAL AS NOMBRE_ALMACEN',
                    'ALMA_NORE AS NOMBRE_RESPONSABLE',
                    'ALMA_APRE AS APELLIDO_PATERNO_RESPONSABLE',
                    'ALMA_AMRE AS APELLIDO_MATERNO_RESPONSABLE',
                    'ALMA_COR1 AS CORREO1',
                    'ALMA_COR2 AS CORREO2',
                    'ALMA_LAD1 AS LADA1',
                    'ALMA_TEL1 AS TELEFONO1',
                    'ALMA_LAD2 AS LADA2',
                    'ALMA_TEL2 AS TELEFONO2',
                    'ALMA_CALL AS CALLE',
                    'ALMA_NUEX AS NUMERO_EXTERIOR',
                    'ALMA_NUIN AS NUMERO_INTERIOR',
                    'ALMA_COPO AS CODIGO_POSTAL',
                    'ALMA_COLO AS COLONIA',
                    'ALMA_LOCA AS LOCALIDAD',
                    'ALMA_MUNI AS MUNICIPIO',
                    'ALMA_ENTI AS ENTIDAD_FEDERATIVA',
                    'ALMA_PAIS AS PAIS',
                    'ALMA_ESTA AS ESTADO',
                    'ALMA_USRE AS USUARIO_REGISTRA',
                    'ALMA_FERE AS FECHA_REGISTRA',
                    'ALMA_USMO AS USUARIO_MODIFICA',
                    'ALMA_FEMO AS FECHA_MODIFICA',
                ]);

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

        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_GETBY001: Ocurrió un error al obtener los almacenes.", 
                $th->getMessage(), 
                500
            );
        }

        if (!empty($arrWarehouse)) {
            $arrResponseGetAddress = $this->resourcesController->getAddress(
                $arrWarehouse['CODIGO_POSTAL'],
                $arrWarehouse['COLONIA'],
                $arrWarehouse['MUNICIPIO'],
                $arrWarehouse['LOCALIDAD'],
                $arrWarehouse['ENTIDAD_FEDERATIVA'],
                $arrWarehouse['PAIS'],
                $line
            );
            if ($arrResponseGetAddress['error']) {
                return $this->responseController->makeResponse(true, 'ERR_arrWarehouse_GETBY002: '.$arrResponseGetAddress['msg'], $arrResponseGetAddress['response'], 406);
            }
    
            $arrWarehouse['CODIGO_POSTAL'] = $arrResponseGetAddress['response']['CODIGO_POSTAL'];
            $arrWarehouse['COLONIA'] = $arrResponseGetAddress['response']['COLONIA'];
            $arrWarehouse['MUNICIPIO'] = $arrResponseGetAddress['response']['MUNICIPIO'];
            $arrWarehouse['LOCALIDAD'] = $arrResponseGetAddress['response']['LOCALIDAD'];
            $arrWarehouse['ENTIDAD_FEDERATIVA'] = $arrResponseGetAddress['response']['ENTIDAD_FEDERATIVA'];
            $arrWarehouse['PAIS'] = $arrResponseGetAddress['response']['PAIS'];
    
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrWarehouse);
    }
    public function getWarehouseActives($user, $line) {
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($user, $line);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_GETBY000:'.$arrResponseCheckUser['msg'], [], 401);
        }
        
        try {
            $arrWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $line)
                ->where('ALMA_ESTA', '=', 'Activo')
                ->get([
                    'ALMA_COAL AS CODIGO_ALMACEN',
                    'ALMA_NOAL AS NOMBRE_ALMACEN',
                    'ALMA_NORE AS NOMBRE_RESPONSABLE',
                    'ALMA_APRE AS APELLIDO_PATERNO_RESPONSABLE',
                    'ALMA_AMRE AS APELLIDO_MATERNO_RESPONSABLE',
                    'ALMA_COR1 AS CORREO1',
                    'ALMA_LAD1 AS LADA1',
                    'ALMA_TEL1 AS TELEFONO1',
                ]);

            $arrWarehouse = json_decode( json_encode($arrWarehouse), true );
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_GET001: Ocurrió un error al obtener los almacenes.", 
                $th->getMessage(), 
                500
            );
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrWarehouse);
    }
    public function createWarehouse( Request $request ) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'NOMBRE_ALMACEN' => 'required|string',
            'NOMBRE_RESPONSABLE' => 'required|string',
            'APELLIDO_PATERNO_RESPONSABLE' => 'required|string',
            'APELLIDO_MATERNO_RESPONSABLE' => 'nullable|string',
            'CORREO1' => 'required|string',
            'CORREO2' => 'nullable|string',
            'LADA1' => 'required|string',
            'TELEFONO1' => 'required|string',
            'LADA2' => 'nullable|string',
            'TELEFONO2' => 'nullable|string',
            'CALLE' => 'required|string',
            'NUMERO_EXTERIOR' => 'required|string',
            'NUMERO_INTERIOR' => 'nullable|string',
            'CODIGO_POSTAL' => 'required|string',
            'COLONIA' => 'required|string',
            'LOCALIDAD' => 'nullable|string',
            'MUNICIPIO' => 'required|string',
            'ENTIDAD_FEDERATIVA' => 'required|string',
            'PAIS' => 'required|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_WAREHOUSE_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

        DB::beginTransaction();
        $requestData = $request->all();
        
        // Se valida y se obtiene el usuario
        $arrResponseCheckUser = $this->resourcesController->checkUserEnc($requestData['USUARIO'], $requestData['NUMERO_LINEA']);
        if ($arrResponseCheckUser['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_REG001:'.$arrResponseCheckUser['msg'], [], 401);
        }
        $user = $arrResponseCheckUser['response'];

        // Se vallidan los campos de dirección
        $arrResponseCheckAddress = $this->resourcesController->validateAddress(
            $requestData['CODIGO_POSTAL'],
            $requestData['COLONIA'],
            $requestData['MUNICIPIO'],
            $requestData['LOCALIDAD'],
            $requestData['ENTIDAD_FEDERATIVA'],
            $requestData['PAIS'],
            $requestData['NUMERO_LINEA'],
        );
        if ($arrResponseCheckAddress['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_REG002: '.$arrResponseCheckAddress['msg'], $arrResponseCheckAddress['response'], 401);
        }
        
        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();

        try {
            $validateInsert = DB::table('S002V01TALMA')->insert([
                'ALMA_NULI' => $requestData['NUMERO_LINEA'],
                'ALMA_COAL' => $requestData['CODIGO_ALMACEN'],
                'ALMA_NOAL' => $requestData['NOMBRE_ALMACEN'],
                'ALMA_NORE' => $requestData['NOMBRE_RESPONSABLE'],
                'ALMA_APRE' => $requestData['APELLIDO_PATERNO_RESPONSABLE'],
                'ALMA_AMRE' => $requestData['APELLIDO_MATERNO_RESPONSABLE'],
                'ALMA_COR1' => $requestData['CORREO1'],
                'ALMA_COR2' => $requestData['CORREO2'],
                'ALMA_LAD1' => $requestData['LADA1'],
                'ALMA_TEL1' => $requestData['TELEFONO1'],
                'ALMA_LAD2' => $requestData['LADA2'],
                'ALMA_TEL2' => $requestData['TELEFONO2'],
                'ALMA_CALL' => $requestData['CALLE'],
                'ALMA_NUEX' => $requestData['NUMERO_EXTERIOR'],
                'ALMA_NUIN' => $requestData['NUMERO_INTERIOR'],
                'ALMA_COPO' => $requestData['CODIGO_POSTAL'],
                'ALMA_COLO' => $requestData['COLONIA'],
                'ALMA_LOCA' => $requestData['LOCALIDAD'],
                'ALMA_MUNI' => $requestData['MUNICIPIO'],
                'ALMA_ENTI' => $requestData['ENTIDAD_FEDERATIVA'],
                'ALMA_PAIS' => $requestData['PAIS'],
                'ALMA_USRE' => $user,
                'ALMA_FERE' => $currentDate,
                'ALMA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_REG003: Ocurrió un error al insertar el registro del almacen.", 
                $th->getMessage(), 
                500
            );
        }
        if (!$validateInsert) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_REG004: No se pudo insertar el registro del almacen.", 
                [], 
                500
            );
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateWarehouse( Request $request, $idWarehouse ) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'NOMBRE_ALMACEN' => 'required|string',
            'NOMBRE_RESPONSABLE' => 'required|string',
            'APELLIDO_PATERNO_RESPONSABLE' => 'required|string',
            'APELLIDO_MATERNO_RESPONSABLE' => 'nullable|string',
            'CORREO1' => 'required|string',
            'CORREO2' => 'nullable|string',
            'LADA1' => 'required|string',
            'TELEFONO1' => 'required|string',
            'LADA2' => 'nullable|string',
            'TELEFONO2' => 'nullable|string',
            'CALLE' => 'required|string',
            'NUMERO_EXTERIOR' => 'required|string',
            'NUMERO_INTERIOR' => 'nullable|string',
            'CODIGO_POSTAL' => 'required|string',
            'COLONIA' => 'required|string',
            'LOCALIDAD' => 'nullable|string',
            'MUNICIPIO' => 'required|string',
            'ENTIDAD_FEDERATIVA' => 'required|string',
            'PAIS' => 'required|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_WAREHOUSE_UPD000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, "ERR_WAREHOUSE_UPD001: Ocurrió un error al desencriptar el ID del almacen.". $th->getMessage(), 406);
        }

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

        $arrResponseCheckAddress = $this->resourcesController->validateAddress(
            $requestData['CODIGO_POSTAL'],
            $requestData['COLONIA'],
            $requestData['MUNICIPIO'],
            $requestData['LOCALIDAD'],
            $requestData['ENTIDAD_FEDERATIVA'],
            $requestData['PAIS'],
            $requestData['NUMERO_LINEA'],
        );
        if ($arrResponseCheckAddress['error']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_UPD003: '.$arrResponseCheckAddress['msg'], $arrResponseCheckAddress['response'], 401);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->update([
                    'ALMA_COAL' => $requestData['CODIGO_ALMACEN'],
                    'ALMA_NOAL' => $requestData['NOMBRE_ALMACEN'],
                    'ALMA_NORE' => $requestData['NOMBRE_RESPONSABLE'],
                    'ALMA_APRE' => $requestData['APELLIDO_PATERNO_RESPONSABLE'],
                    'ALMA_AMRE' => $requestData['APELLIDO_MATERNO_RESPONSABLE'],
                    'ALMA_COR1' => $requestData['CORREO1'],
                    'ALMA_COR2' => $requestData['CORREO2'],
                    'ALMA_LAD1' => $requestData['LADA1'],
                    'ALMA_TEL1' => $requestData['TELEFONO1'],
                    'ALMA_LAD2' => $requestData['LADA2'],
                    'ALMA_TEL2' => $requestData['TELEFONO2'],
                    'ALMA_CALL' => $requestData['CALLE'],
                    'ALMA_NUEX' => $requestData['NUMERO_EXTERIOR'],
                    'ALMA_NUIN' => $requestData['NUMERO_INTERIOR'],
                    'ALMA_COPO' => $requestData['CODIGO_POSTAL'],
                    'ALMA_COLO' => $requestData['COLONIA'],
                    'ALMA_LOCA' => $requestData['LOCALIDAD'],
                    'ALMA_MUNI' => $requestData['MUNICIPIO'],
                    'ALMA_ENTI' => $requestData['ENTIDAD_FEDERATIVA'],
                    'ALMA_PAIS' => $requestData['PAIS'],
                    'ALMA_USMO' => $user,
                    'ALMA_FEMO' => $currentDate,
                    'ALMA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_UPD004: Ocurrió un error al insertar el registro del almacen.", 
                $th->getMessage(), 
                500
            );
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(
                true, 
                "ERR_WAREHOUSE_UPD005: No se pudo insertar el registro del almacen.", 
                [], 
                500
            );
        }

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

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

        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL001: Ocurrió un error al desencriptar el nivel.', $th->getMessage(), 500);
        }

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


        try {
            $validateExists = DB::table('S002V01TALMA')
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->where('ALMA_ESTA', '=', 'Activo')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL003: Ocurrió un error al obtener la información del área.', $th->getMessage(), 500);
        }
        if (!$validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL004: El almacen no existe.', [], 406);
        }


        try {
            $validateExists = DB::table('S002V01TUBAR')
                ->where('UBAR_COAL', '=', $idWarehouse)
                ->where('UBAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('UBAR_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL005: Ocurrió un error al obtener las ubicaciones de los artículos.', $th->getMessage(), 500);
        }
        if($validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL006: No se puede eliminar debido a que existen artículos ubicados en el almacen.', [], 406);
        }


        try {
            $countArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL007: Ocurrió un error al obtener la información del área.', $th->getMessage(), 500);
        }
        if ($countArea > 0) {
            DB::rollBack();
            $quantity = $countArea === 1 ? 'existe 1 área activa' : 'existen'.$countArea.' áreas activas';
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL008: No se puede elminar debido a que '.$quantity.'.', [], 406);
        }


        try {
            $countLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $idWarehouse)
                ->where('NIVE_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL009: Ocurrió un error al obtener las zonas.', $th->getMessage(), 500);
        }
        if ($countLevel > 0) {
            DB::rollBack();
            $quantity = $countLevel === 1 ? 'existe 1 nivel activo' : 'existen '.$countLevel.' niveles activos';
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL010: No se puede eliminar debido a que '.$quantity.'.', [], 406);
        }
        

        try {
            $countZones = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $idWarehouse)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL011: Ocurrió un error al obtener las zonas.', $th->getMessage(), 500);
        }
        if ($countZones > 0) {
            DB::rollBack();
            $quantity = $countZones === 1 ? 'existe 1 zona activa' : 'existen '.$countZones.' zonas activas';
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL012: No se puede eliminar debido a que '.$quantity.'.', [], 406);
        }


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


        try {
            $validateUpdate = DB::table('S002V01TALMA')
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'ALMA_ESTA' => 'Eliminado',
                    'ALMA_USMO' => $user,
                    'ALMA_FEMO' => $currentDate,
                    'ALMA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL013: Ocurrió un error al eliminar el área.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_WAREHOUSE_DEL014: No se pudo eliminar el área.', [], 406);
        }

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

    }

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

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

        try {
            $getArea = DB::table('S002V01TAREA')
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_NULI', '=', $line)
                ->get([
                    'AREA_COAR AS CODIGO_AREA',
                    'AREA_NOAR AS NOMBRE_AREA',
                    'AREA_COME AS COMENTARIOS',
                    'AREA_ESTA AS ESTADO',
                    'AREA_USRE AS USUARIO_REGISTRA',
                    'AREA_FERE AS FECHA_REGISTRA',
                    'AREA_USMO AS USUARIO_MODIFICA',
                    'AREA_FEMO AS FECHA_MODIFICA',
                ]);
            $arrArea = json_decode(json_encode($getArea), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBY002: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrArea);
    }
    public function getAreaById($idArea, $user, $line) {
        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

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

        try {
            $getArea = (array) DB::table('S002V01TAREA')
                ->where('AREA_COAR', '=', $idArea)
                ->where('AREA_NULI', '=', $line)
                ->first([
                    'AREA_NOAR AS NOMBRE_AREA',
                    'AREA_COME AS COMENTARIOS',
                    'AREA_ESTA AS ESTADO',
                    'AREA_USRE AS USUARIO_REGISTRA',
                    'AREA_FERE AS FECHA_REGISTRA',
                    'AREA_USMO AS USUARIO_MODIFICA',
                    'AREA_FEMO AS FECHA_MODIFICA',
                ]);
            $arrArea = json_decode(json_encode($getArea), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBY002: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrArea);
    }
    public function getAreaByWarehouseActives($idWarehouse, $user, $line) {
        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBYACTIVE000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

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

        try {
            $validateExists = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $line)
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBYACTIVE002: Ocurrió un error al obtener el almacen.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBYACTIVE003: El almacen no existe.', [], 401);
        }

        try {
            $getArea = DB::table('S002V01TAREA')
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_NULI', '=', $line)
                ->where('AREA_ESTA', '=', 'Activo')
                ->get([
                    'AREA_COAR AS CODIGO_AREA',
                    'AREA_NOAR AS NOMBRE_AREA',
                    'AREA_COME AS COMENTARIOS',
                ]);
            $arrArea = json_decode(json_encode($getArea), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_AREA_GETBYACTIVE004: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrArea);
    }
    public function registerArea(Request $request) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'CODIGO_AREA' => 'required|string',
            'NOMBRE_AREA' => 'required|string',
            'COMENTARIOS' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_AREA_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

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

        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG002: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG003: El almacen no existe.', [], 406);
        }

        try {
            $validateExistCode = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG004: Ocurrió un error al verificar el código del área.', $th->getMessage(), 500);
        }

        if ($validateExistCode) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG005: El código del área ya se encuentra registrado.', [], 406);
        }

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

        try {
            $validateInsert = DB::table('S002V01TAREA')->insert([
                'AREA_COAL' => $requestData['CODIGO_ALMACEN'],
                'AREA_COAR' => $requestData['CODIGO_AREA'],
                'AREA_NOAR' => $requestData['NOMBRE_AREA'],
                'AREA_COME' => $requestData['COMENTARIOS'],
                'AREA_NULI' => $requestData['NUMERO_LINEA'],
                'AREA_USRE' => $user,
                'AREA_FERE' => $currentDate,
                'AREA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG006: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }

        if (!$validateInsert) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_REG007: No se pudo guardar la información en la base de datos.', [], 406);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateArea(Request $request, $idArea) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'NOMBRE_AREA' => 'required|string',
            'COMENTARIOS' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_AREA_UPD000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }


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


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


        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD002: Ocurrió un error al desencriptar el área.', $th->getMessage(), 500);
        }
        try {
            $validateExistArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAR', '=', $idArea)
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD003: Ocurrió un error al verificar el código del área.', $th->getMessage(), 500);
        }
        if (!$validateExistArea) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD004: El área no existe.', [], 406);
        }


        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD005: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD006: El almacen no existe.', [], 406);
        }


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


        try {
            $validateUpdate = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('AREA_COAR', '=', $idArea)
                ->update([
                    'AREA_NOAR' => $requestData['NOMBRE_AREA'],
                    'AREA_COME' => $requestData['COMENTARIOS'],
                    'AREA_USMO' => $user,
                    'AREA_FEMO' => $currentDate,
                    'AREA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD009: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_UPD010: No se pudo guardar la información en la base de datos.', [], 406);
        }


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

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

        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_DEL001: Ocurrió un error al desencriptar el nivel.', $th->getMessage(), 500);
        }

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

        try {
            $arrArea = (array) DB::table('S002V01TAREA')
                ->where('AREA_COAR', '=', $idArea)
                ->where('AREA_ESTA', '=', 'Activo')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first([
                    'AREA_COAL',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_DEL003: Ocurrió un error al obtener la información del área.', $th->getMessage(), 500);
        }
        if (empty($arrArea)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_DEL004: El área no existe.', [], 406);
        }

        try {
            $validateExists = DB::table('S002V01TUBAR')
                ->where('UBAR_COAL', '=', $arrArea['AREA_COAL'])
                ->where('UBAR_COZO', '=', $idArea)
                ->where('UBAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('UBAR_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_DEL005: Ocurrió un error al obtener las ubicaciones de los artículos.', $th->getMessage(), 500);
        }
        if($validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_AREA_DEL006: No se puede eliminar debido a que existen artículos ubicados en el área.', [], 406);
        }


        try {
            $countLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $arrArea['AREA_COAL'])
                ->where('NIVE_COAR', '=', $idArea)
                ->where('NIVE_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL007: Ocurrió un error al obtener las zonas.', $th->getMessage(), 500);
        }
        if ($countLevel > 0) {
            DB::rollBack();
            $quantity = $countLevel === 1 ? 'existe 1 nivel activo' : 'existen '.$countLevel.' niveles activos';
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL008: No se puede eliminar debido a que '.$quantity.'.', [], 406);
        }


        try {
            $countZones = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $arrArea['AREA_COAL'])
                ->where('ZONA_COAR', '=', $idArea)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL009: Ocurrió un error al obtener las zonas.', $th->getMessage(), 500);
        }
        if ($countZones > 0) {
            DB::rollBack();
            $quantity = $countZones === 1 ? 'existe 1 zona activa' : 'existen '.$countZones.' zonas activas';
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL010: No se puede eliminar debido a que '.$quantity.'.', [], 406);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TAREA')
                ->where('AREA_COAR', '=', $idArea)
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'AREA_ESTA' => 'Eliminado',
                    'AREA_USMO' => $user,
                    'AREA_FEMO' => $currentDate,
                    'AREA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL011: Ocurrió un error al eliminar el área.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL012: No se pudo eliminar el área.', [], 406);
        }

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

    public function getLevelByAreaWarehouse($idWarehouse, $idArea, $user, $line) {
        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBY001: Ocurrió un error al desencriptar el ID del área', $th->getMessage(), 406);
        }

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

        try {
            $getLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_COAL', '=', $idWarehouse)
                ->where('NIVE_COAR', '=', $idArea)
                ->where('NIVE_NULI', '=', $line)
                ->get([
                    'NIVE_CONI AS CODIGO_NIVEL',
                    'NIVE_NONI AS NOMBRE_NIVEL',
                    'NIVE_COME AS COMENTARIOS',
                    'NIVE_ESTA AS ESTADO',
                    'NIVE_USRE AS USUARIO_REGISTRA',
                    'NIVE_FERE AS FECHA_REGISTRA',
                    'NIVE_USMO AS USUARIO_MODIFICA',
                    'NIVE_FEMO AS FECHA_MODIFICA',
                ]);
            $arrLevel = json_decode(json_encode($getLevel), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBY003: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrLevel);
    }
    public function getLevelById( $idLevel, $user, $line ) {
        try {
            $idLevel = $this->encController->decrypt($idLevel);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

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

        try {
            $getLevel = (array) DB::table('S002V01TNIVE')
                ->where('NIVE_CONI', '=', $idLevel)
                ->where('NIVE_NULI', '=', $line)
                ->first([
                    'NIVE_NONI AS NOMBRE_NIVEL',
                    'NIVE_COME AS COMENTARIOS',
                    'NIVE_ESTA AS ESTADO',
                    'NIVE_USRE AS USUARIO_REGISTRA',
                    'NIVE_FERE AS FECHA_REGISTRA',
                    'NIVE_USMO AS USUARIO_MODIFICA',
                    'NIVE_FEMO AS FECHA_MODIFICA',
                ]);
            $arrLevel = json_decode(json_encode($getLevel), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBY002: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrLevel);
    }
    public function getLevelByAreaWarehouseActives($idWarehouse, $idArea, $user, $line) {
        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE001: Ocurrió un error al desencriptar el ID del área', $th->getMessage(), 406);
        }

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

        try {
            $validateExists = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $line)
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE003: Ocurrió un error al obtener el almacen.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE004: El almacen no existe.', [], 401);
        }

        try {
            $validateExists = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $line)
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_COAR', '=', $idArea)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE005: Ocurrió un error al obtener el área.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE006: El área no existe.', [], 401);
        }

        try {
            $getLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_COAL', '=', $idWarehouse)
                ->where('NIVE_COAR', '=', $idArea)
                ->where('NIVE_NULI', '=', $line)
                ->where('NIVE_ESTA', '=', 'Activo')
                ->get([
                    'NIVE_CONI AS CODIGO_NIVEL',
                    'NIVE_NONI AS NOMBRE_NIVEL',
                    'NIVE_COME AS COMENTARIOS',
                ]);
            $arrLevel = json_decode(json_encode($getLevel), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_GETBYACTIVE007: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrLevel);
    }
    public function registerLevel(Request $request) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'CODIGO_AREA' => 'required|string',
            'CODIGO_NIVEL' => 'required|string',
            'NOMBRE_NIVEL' => 'required|string',
            'COMENTARIOS' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_LEVEL_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

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


        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG002: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG003: El almacen no existe.', [], 406);
        }

        try {
            $validateExistArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('AREA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG004: Ocurrió un error al verificar el área.', $th->getMessage(), 500);
        }
        if (!$validateExistArea) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG005: El área no existe.', [], 406);
        }

        try {
            $validateExistLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('NIVE_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('NIVE_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG006: Ocurrió un error al verificar el código del nivel.', $th->getMessage(), 406);
        }
        if ($validateExistLevel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG007: El código del nivel ya existe.', [], 406);
        }


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

        try {
            $validateInsert = DB::table('S002V01TNIVE')->insert([
                'NIVE_NULI' => $requestData['NUMERO_LINEA'],
                'NIVE_COAL' => $requestData['CODIGO_ALMACEN'],
                'NIVE_COAR' => $requestData['CODIGO_AREA'],
                'NIVE_CONI' => $requestData['CODIGO_NIVEL'],
                'NIVE_NONI' => $requestData['NOMBRE_NIVEL'],
                'NIVE_COME' => $requestData['COMENTARIOS'],
                'NIVE_USRE' => $user,
                'NIVE_FERE' => $currentDate,
                'NIVE_FEAR' => DB::raw('CURRENT_TIMESTAMP')
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG008: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }

        if (!$validateInsert) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_REG009: No se pudo guardar la información en la base de datos.', [], 406);
        }

        DB::commit();
        return $this->responseController->makeResponse(false, "ÉXITO: Registro Exitoso");
    }
    public function updateLevel(Request $request, $idLevel) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'NOMBRE_NIVEL' => 'required|string',
            'COMENTARIOS' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_LEVEL_UPD000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

        try {
            $idLevel = $this->encController->decrypt($idLevel);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD001: Ocurrió un error al desencriptar el área.', $th->getMessage(), 500);
        }
        try {
            $validateExistLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_CONI', '=', $idLevel)
                ->where('NIVE_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD002: Ocurrió un error al verificar el código del área.', $th->getMessage(), 500);
        }
        if (!$validateExistLevel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD003: El área no existe.', [], 406);
        }


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


        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD005: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD006: El almacen no existe.', [], 406);
        }
        

        try {
            $validateExistArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('AREA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD007: Ocurrió un error al verificar el área.', $th->getMessage(), 500);
        }
        if (!$validateExistArea) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD008: El área no existe.', [], 406);
        }


        try {
            $validateExistLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('NIVE_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('NIVE_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD009: Ocurrió un error al verificar el código del nivel.', $th->getMessage(), 406);
        }

        if ($validateExistLevel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD010: El código del nivel ya existe.', [], 406);
        }


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


        try {
            $validateUpdate = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('NIVE_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('NIVE_CONI', '=', $idLevel)
                ->update([
                    'NIVE_NONI' => $requestData['NOMBRE_NIVEL'],
                    'NIVE_COME' => $requestData['COMENTARIOS'],
                    'NIVE_USMO' => $user,
                    'NIVE_FEMO' => $currentDate,
                    'NIVE_FEAR' => DB::raw('CURRENT_TIMESTAMP')
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD011: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_UPD012: No se pudo guardar la información en la base de datos.', [], 406);
        }

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

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

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

        try {
            $idLevel = $this->encController->decrypt($idLevel);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL001: Ocurrió un error al desencriptar el nivel.', $th->getMessage(), 500);
        }

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

        try {
            $arrLevel = (array) DB::table('S002V01TNIVE')
                ->where('NIVE_CONI', '=', $idLevel)
                ->where('NIVE_ESTA', '=', 'Activo')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first([
                    'NIVE_COAL',
                    'NIVE_COAR'
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL003: Ocurrió un error al obtener la información del nivel.', $th->getMessage(), 500);
        }
        if (empty($arrLevel)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL004: El nivel no existe.', [], 406);
        }

        try {
            $validateExists = DB::table('S002V01TUBAR')
                ->where('UBAR_COAL', '=', $arrLevel['NIVE_COAL'])
                ->where('UBAR_COAR', '=', $arrLevel['NIVE_COAR'])
                ->where('UBAR_COZO', '=', $idLevel)
                ->where('UBAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('UBAR_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL005: Ocurrió un error al obtener las ubicaciones de los artículos.', $th->getMessage(), 500);
        }
        if($validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL006: No se puede eliminar debido a que existen artículos ubicados en el nivel.', [], 406);
        }

        try {
            $countZones = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $arrLevel['NIVE_COAL'])
                ->where('ZONA_COAR', '=', $arrLevel['NIVE_COAR'])
                ->where('ZONA_CONI', '=', $idLevel)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->count();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL007: Ocurrió un error al obtener las zonas.', $th->getMessage(), 500);
        }
        if ($countZones > 0) {
            DB::rollBack();
            $quantity = $countZones === 1 ? 'existe 1 zona activa' : 'existen '.$countZones.' zonas activas';
            return $this->responseController->makeResponse(true, 'ERR_LEVEL_DEL008: No se puede eliminar debido a que '.$quantity.'.', [], 406);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TNIVE')
                ->where('NIVE_CONI', '=', $idLevel)
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'NIVE_ESTA' => 'Eliminado',
                    'NIVE_USMO' => $user,
                    'NIVE_FEMO' => $currentDate,
                    'NIVE_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL009: Ocurrió un error al eliminar el nivel.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL010: No se pudo eliminar el nivel.', [], 406);
        }

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

    public function getZoneByLevelAreaWarehouse($idWarehouse, $idArea, $idLevel, $user, $line) {
        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }


        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBY001: Ocurrió un error al desencriptar el ID del área', $th->getMessage(), 406);
        }
        

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


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

        try {
            $getZone = DB::table('S002V01TZONA')
                ->where('ZONA_COAL', '=', $idWarehouse)
                ->where('ZONA_COAR', '=', $idArea)
                ->where('ZONA_CONI', '=', $idLevel)
                ->where('ZONA_NULI', '=', $line)
                ->get([
                    'ZONA_COZO AS CODIGO_ZONA',
                    'ZONA_NOZO AS NOMBRE_ZONA',
                    'ZONA_COME AS COMENTARIOS',
                    'ZONA_ESTA AS ESTADO',
                    'ZONA_USRE AS USUARIO_REGISTRA',
                    'ZONA_FERE AS FECHA_REGISTRA',
                    'ZONA_USMO AS USUARIO_MODIFICA',
                    'ZONA_FEMO AS FECHA_MODIFICA',
                ]);
            $arrZone = json_decode(json_encode($getZone), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBY004: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrZone);
    }
    public function getZoneById($idZone, $user, $line) {
        try {
            $idZone = $this->encController->decrypt($idZone);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBY000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }

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

        try {
            $getZone = (array) DB::table('S002V01TZONA')
                ->where('ZONA_COZO', '=', $idZone)
                ->where('ZONA_NULI', '=', $line)
                ->first([
                    'ZONA_NOZO AS NOMBRE_ZONA',
                    'ZONA_COME AS COMENTARIOS',
                    'ZONA_ESTA AS ESTADO',
                    'ZONA_USRE AS USUARIO_REGISTRA',
                    'ZONA_FERE AS FECHA_REGISTRA',
                    'ZONA_USMO AS USUARIO_MODIFICA',
                    'ZONA_FEMO AS FECHA_MODIFICA',
                ]);
            $arrZone = json_decode(json_encode($getZone), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBY002: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrZone);
    }
    public function getZoneByLevelAreaWarehouseActive($idWarehouse, $idArea, $idLevel, $user, $line) {
        try {
            $idWarehouse = $this->encController->decrypt($idWarehouse);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE000: Ocurrió un error al desencriptar el ID del almacen', $th->getMessage(), 406);
        }


        try {
            $idArea = $this->encController->decrypt($idArea);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE001: Ocurrió un error al desencriptar el ID del área', $th->getMessage(), 406);
        }
        

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


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

        try {
            $validateExists = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $line)
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE004: Ocurrió un error al obtener el almacen.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE005: El almacen no existe.', [], 401);
        }

        try {
            $validateExists = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $line)
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_COAR', '=', $idArea)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE006: Ocurrió un error al obtener el área.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE007: El área no existe.', [], 401);
        }

        try {
            $validateExists = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $line)
                ->where('NIVE_COAL', '=', $idWarehouse)
                ->where('NIVE_COAR', '=', $idArea)
                ->where('NIVE_CONI', '=', $idLevel)
                ->exists();
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE008: Ocurrió un error al obtener el nivel.', $th->getMessage(), 406);
        }
        if (!$validateExists) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE009: El nivel no existe.', [], 401);
        }

        try {
            $getZone = DB::table('S002V01TZONA')
                ->where('ZONA_COAL', '=', $idWarehouse)
                ->where('ZONA_COAR', '=', $idArea)
                ->where('ZONA_CONI', '=', $idLevel)
                ->where('ZONA_NULI', '=', $line)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->get([
                    'ZONA_COZO AS CODIGO_ZONA',
                    'ZONA_NOZO AS NOMBRE_ZONA',
                    'ZONA_COME AS COMENTARIOS',
                ]);
            $arrZone = json_decode(json_encode($getZone), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'ERR_ZONE_GETBYACTIVE010: Ocurrió un error al obtener los registros del área.', $th->getMessage(), 406);
        }

        return $this->responseController->makeResponse(false, "ÉXITO: Consulta Exitosa", $arrZone);
    }
    public function registerZone(Request $request) {
        $validator = Validator::make($request->all(), [
            'CODIGO_ALMACEN' => 'required|string',
            'CODIGO_AREA' => 'required|string',
            'CODIGO_NIVEL' => 'required|string',
            'CODIGO_ZONA' => 'required|string',
            'NOMBRE_ZONA' => 'required|string',
            'COMENTARIOS' => 'nullable|string',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);
        if ($validator->fails()) {
            return $this->responseController->makeResponse(
                true,
                "ERR_ZONE_REG000: Se encontraron uno o más errores.",
                $this->responseController->makeErrors($validator->errors()->messages()),
                401
            );
        }

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

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


        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG002: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG003: El almacen no existe.', [], 406);
        }

        try {
            $validateExistArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('AREA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG004: Ocurrió un error al verificar el área.', $th->getMessage(), 500);
        }
        if (!$validateExistArea) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG005: El área no existe.', [], 406);
        }

        try {
            $validateExistNivel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('NIVE_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('NIVE_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->where('NIVE_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG006: Ocurrió un error al verificar el nivel.', $th->getMessage(), 500);
        }
        if (!$validateExistNivel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG007: El nivel no existe.', [], 406);
        }

        try {
            $validateExistZone = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ZONA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('ZONA_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->where('ZONA_COZO', '=', $requestData['CODIGO_ZONA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG008: Ocurrió un error al verificar el código de la zona.', $th->getMessage(), 406);
        }
        if ($validateExistZone) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG009: El código de la zona ya existe.', [], 406);
        }


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

        try {
            $validateInsert = DB::table('S002V01TZONA')->insert([
                'ZONA_NULI' => $requestData['NUMERO_LINEA'],
                'ZONA_COAL' => $requestData['CODIGO_ALMACEN'],
                'ZONA_COAR' => $requestData['CODIGO_AREA'],
                'ZONA_CONI' => $requestData['CODIGO_NIVEL'],
                'ZONA_COZO' => $requestData['CODIGO_ZONA'],
                'ZONA_NOZO' => $requestData['NOMBRE_ZONA'],
                'ZONA_COME' => $requestData['COMENTARIOS'],
                'ZONA_USRE' => $user,
                'ZONA_FERE' => $currentDate,
                'ZONA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
            ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG010: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }

        if (!$validateInsert) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_REG011: No se pudo guardar la información en la base de datos.', [], 406);
        }

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

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

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

        try {
            $idZone = $this->encController->decrypt($idZone);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD001: Ocurrió un error al desencriptar la zona.', $th->getMessage(), 500);
        }
        try {
            $validateExistLevel = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COZO', '=', $idZone)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD002: Ocurrió un error al verificar el código de la zona.', $th->getMessage(), 500);
        }
        if (!$validateExistLevel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD003: El área no existe.', [], 406);
        }


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


        try {
            $validateExistWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ALMA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ALMA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD005: Ocurrió un error al verificar el almacen.', $th->getMessage(), 500);
        }
        if (!$validateExistWarehouse) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD006: El almacen no existe.', [], 406);
        }

        try {
            $validateExistArea = DB::table('S002V01TAREA')
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('AREA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('AREA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('AREA_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD007: Ocurrió un error al verificar el área.', $th->getMessage(), 500);
        }
        if (!$validateExistArea) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD008: El área no existe.', [], 406);
        }

        try {
            $validateExistNivel = DB::table('S002V01TNIVE')
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('NIVE_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('NIVE_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('NIVE_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->where('NIVE_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD009: Ocurrió un error al verificar el nivel.', $th->getMessage(), 500);
        }
        if (!$validateExistNivel) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD010: El nivel no existe.', [], 406);
        }

        try {
            $validateExistZone = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ZONA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('ZONA_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->where('ZONA_COZO', '=', $requestData['CODIGO_ZONA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD011: Ocurrió un error al verificar el código de la zona.', $th->getMessage(), 406);
        }
        if ($validateExistZone) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD012: El código de la zona ya existe.', [], 406);
        }


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

        try {
            $validateUpdate = DB::table('S002V01TZONA')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ZONA_COAL', '=', $requestData['CODIGO_ALMACEN'])
                ->where('ZONA_COAR', '=', $requestData['CODIGO_AREA'])
                ->where('ZONA_CONI', '=', $requestData['CODIGO_NIVEL'])
                ->where('ZONA_COZO', '=', $idZone)
                ->update([
                    'ZONA_NOZO' => $requestData['NOMBRE_ZONA'],
                    'ZONA_COME' => $requestData['COMENTARIOS'],
                    'ZONA_USMO' => $user,
                    'ZONA_FEMO' => $currentDate,
                    'ZONA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD013: Ocurrió un error al ingresar la información a la base de datos.', $th->getMessage(), 500);
        }

        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_UPD014: No se pudo guardar la información en la base de datos.', [], 406);
        }

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

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

        try {
            $idZone = $this->encController->decrypt($idZone);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL001: Ocurrió un error al desencriptar la zona.', $th->getMessage(), 500);
        }

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

        try {
            $arrZone = (array) DB::table('S002V01TZONA')
                ->where('ZONA_COZO', '=', $idZone)
                ->where('ZONA_ESTA', '=', 'Activo')
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->first([
                    'ZONA_COAL',
                    'ZONA_COAR',
                    'ZONA_CONI',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL003: Ocurrió un error al obtener la información de la zona.', $th->getMessage(), 500);
        }
        if (empty($arrZone)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL004: La zona no existe.', [], 406);
        }


        try {
            $validateExists = DB::table('S002V01TUBAR')
                ->where('UBAR_COAL', '=', $arrZone['ZONA_COAL'])
                ->where('UBAR_COAR', '=', $arrZone['ZONA_COAR'])
                ->where('UBAR_CONI', '=', $arrZone['ZONA_CONI'])
                ->where('UBAR_COZO', '=', $idZone)
                ->where('UBAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('UBAR_ESTA', '=', 'Activo')
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL005: Ocurrió un error al obtener las ubicaciones de los artículos.', $th->getMessage(), 500);
        }
        if($validateExists) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL006: No se puede eliminar debido a que existen artículos ubicados en la zona.', [], 406);
        }

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

        try {
            $validateUpdate = DB::table('S002V01TZONA')
                ->where('ZONA_COZO', '=', $idZone)
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->update([
                    'ZONA_ESTA' => 'Eliminado',
                    'ZONA_USMO' => $user,
                    'ZONA_FEMO' => $currentDate,
                    'ZONA_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL007: Ocurrió un error al eliminar la zona.', $th->getMessage(), 500);
        }
        if (!$validateUpdate) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'ERR_ZONE_DEL008: No se pudo eliminar la zona.', [], 406);
        }

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

    // FUNCIÓN RECEPCIÓN DE ARTÍCULOS
    public function registerToStock(Request $request) {
        $validator = Validator::make($request->all(), [
            'WAREHOUSE' => 'required|string',
            'AREA' => 'required|string',
            'LEVEL' => 'required|string',
            'ZONE' => 'required|string',
            'ORDER' => 'required|string',
            'PRE_CODIFICATE' => 'required|array',
            'ID_INFORMATION' => 'required|integer',
            'FAMILIA' => 'required|string',
            'SUBFAMILIA' => 'required|string',
            'MODELO' => 'required|string',
            'CODIGO_MODELO' => 'required|string',
            'NUMBER_ITEMS' => 'required|integer',
            'CODIGO_BARRAS' => 'required|string',
            'FECHA_VENCIMIENTO' => 'nullable|string',
            'IMAGES' => 'required|json',
            'PRE_GENERATED_CODE' => 'required|string',
            'REPARABLE' => 'required|boolean',
            'CONSUMIBLE' => 'required|boolean',
            'USUARIO' => 'required|string',
            'NUMERO_LINEA' => 'required|string',
        ]);

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


        // Se verifica la precodificación
        if ( count($requestData['PRE_CODIFICATE']) !== $requestData['NUMBER_ITEMS']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La cantidad registrada de la precodificación no es igual la cantidad de artículos seleccionados.', [], 500);
        }

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


        // Se obtiene la información encriptada
        try {
            $idWarehouse = $this->encController->decrypt($requestData['WAREHOUSE']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener el almacen.', $th->getMessage(), 500);
        }
        if ($idWarehouse === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptación del almacen no es correcta.', [], 500);
        }
        try {
            $idArea = $this->encController->decrypt($requestData['AREA']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener el área.', $th->getMessage(), 500);
        }
        if ($idArea === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptacipon del área no es correcta.', [], 500);
        }
        try {
            $idLevel = $this->encController->decrypt($requestData['LEVEL']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener el nivel.', $th->getMessage(), 500);
        }
        if ($idLevel === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptación del nivel no es correcta.', [], 500);
        }
        try {
            $idZone = $this->encController->decrypt($requestData['ZONE']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la zona.', $th->getMessage(), 500);
        }
        if ($idZone === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptación de la zona no es correcta.', [], 500);
        }

        try {
            $idFamily = $this->encController->decrypt($requestData['FAMILIA']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la familia.', $th->getMessage(), 500);
        }
        if ($idFamily === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptación de la familia no es correcta.', [], 500);
        }
        try {
            $idSubfamily = $this->encController->decrypt($requestData['SUBFAMILIA']);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la subfamilia.', $th->getMessage(), 500);
        }
        if ($idSubfamily === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La encriptación de la subfamilia no es correcta.', [], 500);
        }


        // Se verifica que la información exista
        try {
            $validateWarehouse = DB::table('S002V01TALMA')
                ->where('ALMA_COAL', '=', $idWarehouse)
                ->where('ALMA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si el almacen existe.', $th->getMessage(), 500);
        }
        if ($validateWarehouse === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El almacen no existe.', [], 500);
        }

        try {
            $validateArea = DB::table('S002V01TAREA')
                ->where('AREA_COAL', '=', $idWarehouse)
                ->where('AREA_COAR', '=', $idArea)
                ->where('AREA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si el área existe.', $th->getMessage(), 500);
        }
        if ($validateArea === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El área no existe.', [], 500);
        }

        try {
            $validateLevel = DB::table('S002V01TNIVE')
                ->where('NIVE_COAL', '=', $idWarehouse)
                ->where('NIVE_COAR', '=', $idArea)
                ->where('NIVE_CONI', '=', $idLevel)
                ->where('NIVE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si el nivel existe.', $th->getMessage(), 500);
        }
        if ($validateLevel === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'El nivel no existe.', [], 500);
        }
        
        try {
            $validateZone = DB::table('S002V01TZONA')
                ->where('ZONA_COAL', '=', $idWarehouse)
                ->where('ZONA_COAR', '=', $idArea)
                ->where('ZONA_CONI', '=', $idLevel)
                ->where('ZONA_COZO', '=', $idZone)
                ->where('ZONA_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si la zona existe.', $th->getMessage(), 500);
        }
        if ($validateZone === false) {
            return $this->responseController->makeResponse(true, 'La zona no existe.', [], 500);
        }


        try {
            $validateFamily = DB::table('S002V01TFAMI')
                ->where('FAMI_COFA', '=', $idFamily)
                ->where('FAMI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si la familia existe.', $th->getMessage(), 500);
        }
        if ($validateFamily === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La familia no existe.', [], 500);
        }
        try {
            $validateSubfamily = DB::table('S002V01TSUBF')
                ->where('SUBF_COFA', '=', $idFamily)
                ->where('SUBF_COSU', '=', $idSubfamily)
                ->where('SUBF_NULI', '=', $requestData['NUMERO_LINEA'])
                ->exists();
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar si la subfamilia existe.', $th->getMessage(), 500);
        }
        if ($validateSubfamily === false) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La subfamilia no existe.', [], 500);
        }

        try {
            $orden = (array) DB::table('S002V01TORCO')
                ->where('ORCO_NUOR', '=', $requestData['ORDER'])
                ->where('ORCO_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ORCO_ESTA', '=', 'Recibido')
                ->first([
                    'ORCO_IDLI AS ID_LINEA_SOLICITUD',
                    'ORCO_IDDE AS ID_DESCRIPCION',
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información de la orden de compra.', $th->getMessage(), 500);
        }
        if (is_null($orden)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La orden de compra no existe.', [], 500);
        }

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

        try {
            $info = DB::table('S002V01TARSE')
                ->where('ARSE_IDIN', '=', $requestData['ID_INFORMATION'])
                ->where('ARSE_ESTA', '=', 'Activo')
                ->where('ARSE_IDLI', '=', $orden['ID_LINEA_SOLICITUD'])
                ->where('ARSE_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ARTI_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('DEAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('UNID_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('INAR_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('ARSE_ESTA', '=', 'Activo')
                ->where('ARTI_ESTA', '=', 'Activo')
                ->where('DEAR_ESTA', '=', 'Activo')
                ->where('UNID_ESTA', '=', 'Activo')
                ->where('INAR_ESTA', '=', 'Activo')
                ->where('INAR_CODI', '=', $requestData['CODIGO_MODELO'])
                ->where('INAR_MODE', '=', $requestData['MODELO'])
                ->join('S002V01TARTI', 'ARTI_IDAR', '=', 'ARSE_IDAR')
                ->join('S002V01TINAR', 'INAR_IDIN', '=', 'ARSE_IDIN')
                ->join('S002V01TDEAR', 'DEAR_IDDE', '=', 'INAR_IDDE')
                ->join('S002V01TUNID', 'UNID_IDUN', '=', 'DEAR_IDUN')
                ->limit($requestData['NUMBER_ITEMS'])
                ->get([
                    'ARSE_IDAS AS NUMERO_SELECCIONADO',

                    'ARTI_IDAR AS ID_ARTICULO',
                    'ARTI_COFA AS CODIGO_FAMILIA',
                    'ARTI_COSU AS CODIGO_SUBFAMILIA',
                    'ARTI_CODI AS CODIGO_ARTICULO',
                    'ARTI_NOMB AS NOMBRE_ARTICULO',

                    'DEAR_IDDE AS ID_DESCRIPCION', 
                    'DEAR_IMAG AS IMAGENES', 
                    'DEAR_DESC AS DESCRIPCION', 
                    'DEAR_CARA AS CARACTERISTICAS', 
                    'DEAR_COWE AS COMPRA_WEB', 
                    'DEAR_NUPR AS NUMERO_PROVEEDOR', 
                    
                    'UNID_IDUN AS ID_UNIDAD',
                    'UNID_NOMB AS NOMBRE_UNIDAD',
                    'UNID_ACRO AS ACRONIMO_UNIDAD',

                    'INAR_IDIN AS ID_INFORMACION',
                    'INAR_CODI AS CODIGO_INFORMACION',
                    'INAR_MODE AS MODELO_INFORMACION',
                    'INAR_COMO AS CODIGO_MONEDA',
                    'INAR_PREC AS PRECIO',
                    'INAR_MOMI AS MONTO_MINIMO',
                    'INAR_CARA AS CARACTERISTICAS',
                ]);
            $info = json_decode(json_encode($info ), true);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información de los productos.', $th->getMessage(), 500);
        }
        if ( is_null($info) || empty($info) ) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No existen artículos asociados a la orden de compra.', [], 500);
        }

        // Se verifica que existan los datos suficientes para hacer el traslado.
        if ( count($info) !== $requestData['NUMBER_ITEMS']) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'La cantidad de artículos en la orden de compra no corresponde a la cantidad de artículos seleccionados a Stock.', [], 500);
        }

        // Se verifica los códigos de barras
        $uniqueBarcode = false;
        $arrBarcode = explode(',', $requestData['CODIGO_BARRAS']);
        if ( count($arrBarcode) === 0) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No hay códigos de barras registrados.', [], 500);
        } else if (count($arrBarcode) === $requestData['NUMBER_ITEMS']) {
            $uniqueBarcode = false;
        } else if (array_key_exists(0, $arrBarcode) && count($arrBarcode) === 1 && $arrBarcode[0] !== '' ) {
            $uniqueBarcode = true;
        } else {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error con los códigos de barras registrados.', [], 500);
        }

        // Se verifica que los códigos de barras del formulario no sean repetidos
        $temp_array = array_unique($arrBarcode);
        $duplicates = sizeof($temp_array) != sizeof($arrBarcode);
        if ($duplicates) {
            return $this->responseController->makeResponse(true, 'Los códigos de barras no se pueden repetir.', [], 400);
        }

        // Se verifican que los códigos de barras no se repitan
        foreach ($arrBarcode as $key => $barcode) {
            try {
                $validateBarcode = DB::table('S002V01TSTAR')
                    ->where('STAR_COBA', '=', $barcode)
                    ->where('STAR_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->exists();
            } catch (\Throwable $th) {
                return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar los códigos de barras.', $th->getMessage(), 500);
            }
            if ($validateBarcode === true) {
                return $this->responseController->makeResponse(true, 'El código '.$barcode.' ya se encuentra registrado', [], 500);
            }
        }

        // Se verifica la fecha de vencimientos
        $arrDueDate = array();
        $uniqueDueDate = false;
        if ($requestData['FECHA_VENCIMIENTO'] !== '' && !is_null($requestData['FECHA_VENCIMIENTO'])) {
            $arrDueDate = explode(',', $requestData['FECHA_VENCIMIENTO']);
            if ( count($arrDueDate) === 0) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No hay fechas de vencimientos registradas.', [], 500);
            } else if (count($arrDueDate) === $requestData['NUMBER_ITEMS']) {
                $uniqueDueDate = false;
            } else if (array_key_exists(0, $arrDueDate) && count($arrDueDate) === 1 && $arrDueDate[0] !== '' ) {
                $uniqueDueDate = true;
            } else {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error con las fechas de vencimientos registrados.', [], 500);
            }
        }
       

        // Se obtiene la fecha actual
        $now = $this->functionsController->now();
        $currentDate = $now->toDateTimeString();
         
        $idInfoStock = null;
        try {
            $infoStock = (array) DB::table('S002V01TINST')
                ->where('INST_COFA', '=', $idFamily)
                ->where('INST_COSU', '=', $idSubfamily)
                ->where('INST_ARTI', '=', $info[0]['ID_ARTICULO'])
                ->where('INST_MODE', '=', $requestData['MODELO'])
                ->where('INST_COMO', '=', $requestData['CODIGO_MODELO'])
                ->where('INST_NULI', '=', $requestData['NUMERO_LINEA'])
                ->where('INST_ESTA', '=', 'Activo')
                ->first([
                    'INST_IDIS AS ID_INFO_STOCK'
                ]);
        } catch (\Throwable $th) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'Ocurrió un error al verificar la información del stock.', $th->getMessage(), 500);
        }
        if (empty($infoStock) || is_null($infoStock)) {
            // Se obtiene el arreglo de las imagenes
            $imagesArr = json_decode($requestData['IMAGES'], true);
            // Se verifica que el arreglo contenga imagenes
            if(count($imagesArr) < 1){
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'El arreglo de la galería de imágenes está vacío.', [], 400);
            }

            $imagesGallery = [];
            // Se iteran las imagenes
            foreach($imagesArr as $imageFile){
                // Se verifica que tenga un formato correcto
                if(!array_key_exists('type', $imageFile)){
                    DB::rollBack();
                    return $this->responseController->makeResponse(true, 'El arreglo de la galería de imágenes tiene un formato inválido.', [], 400);
                // Si la imagen es nueva, entonces...
                }else if($imageFile['type'] == 'Nuevo'){
                    // Se obtiene el ID de la imagen
                    $tempFileID = $this->encController->decrypt($imageFile['id']);
                    // Se obtiene la información registrada en la tabla de archivos temporales
                    $tempFile = DB::table('S002V01TARTE')->where([
                        ['ARTE_IDAR', '=', $tempFileID],
                        ['ARTE_NULI', '=', $requestData['NUMERO_LINEA']]
                    ])->first();
                    // La imagen es colocada en su posición final
                    $finalFile = $this->documentManagementController->moveFinalFile($requestData['NUMERO_LINEA'], 'GEEQ', 'FO', $tempFile, $user);
                    // Si ocurrió un error, entonces se manda el error
                    if(!$finalFile[0]){
                        return $this->responseController->makeResponse(true, $finalFile[1], [], 400);
                    }
                    // La información es guardada en un arreglo
                    $imagesGallery[] = $finalFile[1];
                }else{
                    // Se desencripta el id de la imagen
                    $fileID = $this->encController->decrypt($imageFile['id']);
                    // Es guardada en un arreglo
                    $imagesGallery[] = $fileID;
                }
            }

            // El arreglo de las imagenes es pasada en formato string
            $imagesGalleryStr = json_encode($imagesGallery);

            try {
                $idInsert = DB::table('S002V01TINST')->insertGetId([
                    'INST_NULI' => $requestData['NUMERO_LINEA'],
                    'INST_COFA' => $idFamily,
                    'INST_COSU' => $idSubfamily,
                    'INST_ARTI' => $info[0]['ID_ARTICULO'],
                    'INST_MODE' => $requestData['MODELO'],
                    'INST_COMO' => $requestData['CODIGO_MODELO'],
                    'INST_IMAG' => $imagesGalleryStr,
                    'INST_USRE' => $user,
                    'INST_FERE' => $currentDate,
                    'INST_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al insertar la información del stock.', $th->getMessage(), 500);
            }
            if ($idInsert === false || is_null($idInsert)) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo insertar la información del stock.', [], 500);
            }

            $idInfoStock = $idInsert;
        } else {
            $idInfoStock = $infoStock['ID_INFO_STOCK'];
        }
        if (is_null($idInfoStock)) {
            DB::rollBack();
            return $this->responseController->makeResponse(true, 'No se pudo obtener el ID de la información del Stock.', [], 500);
        }

        for ($i=0; $i < $requestData['NUMBER_ITEMS']; $i++) { 
            
            $dueDate = null;
            if (count($arrDueDate) > 0 && $uniqueDueDate === true) {
                $dueDate = $arrDueDate[0];
            } else if (count($arrDueDate) > 0 && $uniqueDueDate === false) {
                $dueDate = $arrDueDate[$i];
            }

            if (!is_null($dueDate) && str_contains($dueDate, 'T')) {
                $dueDate = explode('T', $dueDate)[0];
            }

            try {
                $preCodificate = $this->encController->decrypt($requestData['PRE_CODIFICATE'][$i]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el identificador de la pre-codificación.', $th->getMessage(), 500);
            }
            if ($preCodificate === false) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo desencriptar el identificador de la pre-codificación.', [], 500);
            }


            try {
                $idInsertStAr = DB::table('S002V01TSTAR')->insertGetId([
                    'STAR_NULI' => $requestData['NUMERO_LINEA'],
                    'STAR_IDIS' => $idInfoStock,
                    'STAR_COBA' => $uniqueBarcode === true ? $arrBarcode[0] : $arrBarcode[$i],
                    'STAR_FEVE' => $dueDate,
                    'STAR_IDUN' => $info[$i]['ID_UNIDAD'],
                    'STAR_NUPR' => $info[$i]['NUMERO_PROVEEDOR'],
                    'STAR_TIAD' => 'Por pedido',
                    'STAR_IDPC' => $preCodificate,
                    'STAR_CONS' => $requestData['CONSUMIBLE'] ? 'Si' : 'No',
                    'STAR_REPA' => $requestData['REPARABLE'] ? 'Si' : 'No',
                    'STAR_ESTA' => 'Pendiente',
                    'STAR_USRE' => $user,
                    'STAR_FERE' => $currentDate,
                    'STAR_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al registrar el equipamiento.', $th->getMessage(), 500);
            }
            if ($idInsertStAr === false || is_null($idInsertStAr)) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo registrar el equipamiento.', [], 500);
            }

            try {
                $preCodeCodificate = $this->encController->decrypt($requestData['PRE_GENERATED_CODE']);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al desencriptar el pre-código generado', $th->getMessage(), 500);
            }
            if ( $preCodeCodificate === false ) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo desencriptar el pre-código del equipamientos.', [], 500);
            }

           
            try {
                $validateInsertUbAr = DB::table('S002V01TUBAR')->insert([
                    'UBAR_NULI' => $requestData['NUMERO_LINEA'],
                    'UBAR_COAL' => $idWarehouse,
                    'UBAR_COAR' => $idArea,
                    'UBAR_CONI' => $idLevel,
                    'UBAR_COZO' => $idZone,
                    'UBAR_IDST' => $idInsertStAr,
                    'UBAR_COUB' => $preCodeCodificate,
                    'UBAR_ESTA' => 'Pendiente',
                    'UBAR_USRE' => $user,
                    'UBAR_FERE' => $currentDate,
                    'UBAR_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al registrar la ubicación del artículo.', $th->getMessage(), 500);
            }
            if ( $validateInsertUbAr === false ) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo registrar la ubicación del artículo.', [], 500);
            }


            try {
                $validateUpdateArSe = DB::table('S002V01TARSE')
                    ->where('ARSE_IDAS', '=', $info[$i]['NUMERO_SELECCIONADO'])
                    ->where('ARSE_NULI', '=', $requestData['NUMERO_LINEA'])
                    ->where('ARSE_IDLI', '=', $orden['ID_LINEA_SOLICITUD'])
                    ->where('ARSE_IDAR', '=', $info[$i]['ID_ARTICULO'])
                    ->where('ARSE_NUPR', '=', $info[$i]['NUMERO_PROVEEDOR'])
                    ->where('ARSE_IDIN', '=', $requestData['ID_INFORMATION'])
                    ->where('ARSE_ESTA', '=', 'Activo')
                    ->update([
                        'ARSE_ESTA' => 'Guardado',
                        'ARSE_USMO' => $user,
                        'ARSE_FEMO' => $currentDate,
                        'ARSE_FEAR' => DB::raw('CURRENT_TIMESTAMP'),
                    ]);
            } catch (\Throwable $th) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'Ocurrió un error al modificar el artículo seleccionado.', $th->getMessage(), 500);
            }
            if ($validateUpdateArSe === false) {
                DB::rollBack();
                return $this->responseController->makeResponse(true, 'No se pudo modificar el artículo seleccionado.', [], 500);
            }
        }

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

    // FUNCIÓN INTERCAMBIO DE ARTICULOS ENTRE ALMACENES
    public function getCurrentLocationArtitles($user, $line) {
        try {
            $arrStockArtitle = DB::table('S002V01TSTAR')
                ->where('STAR_NULI', '=', $line)
                ->where('STAR_ESTA', '=', 'Activo')
                ->where('INST_NULI', '=', $line)
                ->where('INST_ESTA', '=', 'Activo')
                ->where('UBAR_ESTA', '=', 'Activo')
                ->join('S002V01TUBAR', 'UBAR_IDST', '=', 'STAR_IDST')
                ->join('S002V01TINST', 'INST_IDIS', '=', 'STAR_IDIS')
                ->join('S002V01TFAMI', 'FAMI_COFA', '=', 'INST_COFA')
                ->join('S002V01TSUBF', 'SUBF_COSU', '=', 'INST_COSU')
                ->join('S002V01TALMA', 'ALMA_COAL', '=', 'UBAR_COAL')
                ->join('S002V01TAREA', 'AREA_COAR', '=', 'UBAR_COAR')
                ->join('S002V01TNIVE', 'NIVE_CONI', '=', 'UBAR_CONI')
                ->join('S002V01TZONA', 'ZONA_COZO', '=', 'UBAR_COZO')
                ->get([
                    'STAR_IDST AS ID_STOCK',
                    'INST_IDIS AS ID_INFORMACION_STOCK',
                    'FAMI_NOFA AS NOMBRE_FAMILIA',
                    'SUBF_NOSU AS NOMBRE_SUBFAMILIA',
                    'INST_ARTI AS ARTITULO',
                    'INST_MODE AS MODELO',
                    'INST_COMO AS CODIGO_MODELO',
                    'INST_IMAG AS IMAGENES',
                    'UBAR_COUB AS CODIGO',
                    DB::raw('CONCAT(ALMA_NOAL, " (", ALMA_COAL, ")") AS NOMBRE_ALMACEN'),
                    DB::raw('CONCAT(AREA_NOAR, " (", AREA_COAR, ")") AS NOMBRE_AREA'),
                    DB::raw('CONCAT(NIVE_NONI, " (", NIVE_CONI, ")") AS NOMBRE_NIVEL'),
                    DB::raw('CONCAT(ZONA_NOZO, " (", ZONA_COZO, ")") AS NOMBRE_ZONA'),
                ]);
            $arrStockArtitle = json_decode(json_encode($arrStockArtitle), true);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información del stock.', $th->getMessage(), 500);
        }

        foreach ($arrStockArtitle as $key => $stockArtitle) {
            $imagesGallery = [];
            $arrImages = json_decode($stockArtitle['IMAGENES']);
            foreach($arrImages as $image) {
                $imageCodeEnc = $this->encController->encrypt($image);
                $response = $this->documentManagementController->privateGetPublicDocumentURL(
                    $imageCodeEnc,
                    $user,
                    $line
                );
                if($response['error']){
                    return $this->responseController->makeresponse(true, $response['msg'], [], 500);
                }
                $imagesGallery[] = $response['response']['public_uri'];
            }
            $stockArtitle['IMAGENES'] = $imagesGallery;
            $arrStockArtitle[$key] = $stockArtitle;
        }

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

    // FUNCIÓN PARA JOSÉ LUIS
    public function getInfoStock($user, $line) {

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

        try {
            $arrStockArtitle = DB::table('S002V01TSTAR')
                ->where('STAR_NULI', '=', $line)
                ->where('STAR_ESTA', '=', 'Activo')
                ->where('INST_NULI', '=', $line)
                ->where('INST_ESTA', '=', 'Activo')
                ->where('UBAR_ESTA', '=', 'Activo')
                ->join('S002V01TUBAR', 'UBAR_IDST', '=', 'STAR_IDST')
                ->join('S002V01TINST', 'INST_IDIS', '=', 'STAR_IDIS')
                ->get([
                    'STAR_IDST AS ID_STOCK',
                    'INST_MODE AS MODELO',
                    'INST_COMO AS CODIGO_MODELO',
                    'UBAR_COUB AS CODIGO_EQUIPAMIENTO',
                    'STAR_CONS AS CONSUMIBLE',
                    'STAR_REPA AS REPARABLE',
                ]);
        } catch (\Throwable $th) {
            return $this->responseController->makeResponse(true, 'Ocurrió un error al obtener la información del stock.', $th->getMessage(), 500);
        }

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