EVOLUTION-MANAGER

Edit File: crudlotaip.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Lotaip;
use App\Datos_lotaip;
use App\Lotaipvigente;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Log;

class crudlotaip extends Controller
{
    public function index()
    {
        $anio = Lotaip::selectraw('anios as anio')
            ->orderBy('anio', 'desc')
            ->distinct()
            ->get();

$meses = [];
        foreach ($anio as $date) {
            $mes = lotaip::select('mes', 'anios', 'id_lotaip')
                ->where('anios', $date->anio)
                ->orderByRaw("
                    CASE mes
                        WHEN 'Enero' THEN 1
                        WHEN 'Febrero' THEN 2
                        WHEN 'Marzo' THEN 3
                        WHEN 'Abril' THEN 4
                        WHEN 'Mayo' THEN 5
                        WHEN 'Junio' THEN 6
                        WHEN 'Julio' THEN 7
                        WHEN 'Agosto' THEN 8
                        WHEN 'Septiembre' THEN 9
                        WHEN 'Octubre' THEN 10
                        WHEN 'Noviembre' THEN 11
                        WHEN 'Diciembre' THEN 12
                        ELSE 13
                    END ASC
                ")
                ->distinct()
                ->get();
            array_push($meses, $mes);
        }

$lotaip = Datos_lotaip::select('id_datos_lotaip', 'archivo', 'posicion', 'id_lotaip', 'id_lotaipvigente')
            ->orderBy('id_lotaipvigente', 'asc')
            ->orderBy('posicion', 'asc')
            ->get();

$lotaipvigente = Lotaipvigente::select('id_lotaipvigente', 'titulo', 'orden')
            ->orderBy('id_lotaipvigente', 'asc')
            ->get();

return view('web-administrador-lotaip/crudlotaip', compact('anio', 'meses', 'lotaip', 'lotaipvigente'));
    }

public function show_crear()
    {
        $mesanio = lotaip::select('anios', 'mes')
            ->orderBy('anios', 'asc')
            ->orderBy('mes', 'asc')
            ->get();

$lotaipvigente = Lotaipvigente::select('id_lotaipvigente', 'titulo', 'orden')
            ->orderBy('id_lotaipvigente', 'asc')
            ->limit('25')
            ->get();

return view("web-administrador-lotaip/crear_lotaip", compact('lotaipvigente', 'mesanio'));
    }

public function crear_lotaip(Request $request)
    {
        DB::beginTransaction();

try {
            $validatedData = $request->validate([
                'anio' => 'required|max:10',
                'mes' => 'required|max:10',
                'lotapvigente' => 'required|max:50',
                'documentos.*' => 'file',
                'idlotaipvigente.*' => 'max:3',
                'orden.*' => 'max:3',
            ]);

$exists = DB::table('lotaip')
                ->where('anios', $request->input('anio'))
                ->where('mes', $request->input('mes'))
                ->exists();

if ($exists) {
                throw ValidationException::withMessages([
                    'anio_mes' => 'Ya existe un registro con ese año y mes creado.',
                ]);
            }

if ($request->file('documentos')) {
                $nombre_archivos = [];
                $documentos = $request->file('documentos');

if (count($documentos) % 4 === 0) {
                    foreach ($documentos as $docu) {
                        $filename = time() . "-" . $docu->getClientOriginalName();
                        // Almacenar el archivo en el disco de Google
                        Storage::disk('google')->put($filename, file_get_contents($docu->getRealPath()));
                        array_push($nombre_archivos, $filename);
                    }

$dir = "/";
                    $recursive = false;
                    $archivo_cod = [];
                    $contents = collect(Storage::disk("google")->listContents($dir, $recursive));
                    for ($x = 0; $x < count($nombre_archivos); $x++) {
                        $fileid = $contents->where("type", "file")
                            ->where("filename", pathinfo($nombre_archivos[$x], PATHINFO_FILENAME))
                            ->where("extension", pathinfo($nombre_archivos[$x], PATHINFO_EXTENSION))
                            ->first();
                        if ($fileid)
                            array_push($archivo_cod, $fileid["path"]);
                    }

$array_lotaipvigente = [];
                    $Orden = $request->input('idlotaipvigente');
                    foreach ($Orden as $option) {
                        array_push($array_lotaipvigente, $option);
                    }

$array_orden = [];
                    $Orden_archivo = $request->input('orden');
                    foreach ($Orden_archivo as $option) {
                        array_push($array_orden, $option);
                    }

$lotaip = new Lotaip();
                    $lotaip->mes = $request->mes;
                    $lotaip->anios = $request->anio;
                    $lotaip->save();

$id = $lotaip->getKey();

for ($i = 0; $i < count($archivo_cod); $i++) {
                        $datos_lotaip = new Datos_lotaip();
                        $datos_lotaip->archivo = $archivo_cod[$i];
                        $datos_lotaip->posicion = $array_orden[$i];
                        $datos_lotaip->id_lotaip = $id;
                        $datos_lotaip->id_lotaipvigente = $array_lotaipvigente[$i];
                        $datos_lotaip->save();
                    }

$creadas = Datos_lotaip::select('id_lotaipvigente')
                        ->where('id_lotaip', $id)
                        ->distinct()
                        ->get();

$cantidad_id = [];
                    foreach ($creadas as $dato) {
                        array_push($cantidad_id, $dato->id_lotaipvigente);
                    }

$cuatro = 0;
                    $veinticinco = 1;

for ($i = 0; $i < 100; $i++) {
                        $cuatro++;

// Si el valor actual de $veinticinco está en $cantidad_id, salta 4 posiciones
                        if (in_array($veinticinco, $cantidad_id)) {
                            $i += 3;
                            $veinticinco++;
                            $cuatro = 0; // Reinicia $cuatro
                            continue; // Salta a la siguiente iteración
                        }

// Crear y guardar un nuevo registro de Datos_lotaip
                        $datos_lotaip = new Datos_lotaip();
                        $datos_lotaip->archivo = null;
                        $datos_lotaip->posicion = $cuatro;
                        $datos_lotaip->id_lotaip = $id;
                        $datos_lotaip->id_lotaipvigente = $veinticinco;
                        $datos_lotaip->save();

// Incrementar $veinticinco y resetear $cuatro cuando se llega a 4
                        if ($cuatro == 4) {
                            $veinticinco++;
                            $cuatro = 0;
                        }
                    }
                } else
                    return response()->json(['error' => 'Error si sube archivos de uno o varios literales debe completarlos 4/4']);
            } else {
                $lotaip = new Lotaip();
                $lotaip->mes = $request->mes;
                $lotaip->anios = $request->anio;
                $lotaip->save();

$id = $lotaip->getKey();

$cuatro = 0;
                $veinticinco = 1;
                for ($i = 0; $i < 100; $i++) {
                    $cuatro++;
                    $datos_lotaip = new Datos_lotaip();
                    $datos_lotaip->archivo = null;
                    $datos_lotaip->posicion = $cuatro;
                    $datos_lotaip->id_lotaip = $id;
                    $datos_lotaip->id_lotaipvigente = $veinticinco;
                    $datos_lotaip->save();
                    if ($cuatro == 4) {
                        $veinticinco++;
                        $cuatro = 0;
                    }
                }
            }

DB::commit();

return response()->json(['success' => true, 'message' => 'Creación exitosa!']);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['error_validacion' => $e->errors()]);
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error inesperado. Por favor, inténtelo de nuevo más tarde.']);
        }
    }

public function editar_lotaip(Request $request)
    {
        DB::beginTransaction();

try {
            // Validación de la solicitud
            $validatedData = $request->validate([
                'id.*' => 'required',
                'documentos.*' => 'required|file',
            ]);

// Verificación de que el número de IDs coincide con el número de documentos
            if (count($request->input('id')) !== count($request->file('documentos'))) {
                return response()->json(['error' => 'El número de IDs no coincide con el número de documentos subidos.']);
            }

$nombre_archivos = [];
            $documentos = $request->file('documentos');

// Almacenar los archivos en Google Drive y guardar los nombres en $nombre_archivos
            foreach ($documentos as $docu) {
                $filename = time() . "-" . $docu->getClientOriginalName();
                Storage::disk('google')->put($filename, file_get_contents($docu->getRealPath()));
                array_push($nombre_archivos, $filename);
            }

$id_ = $request->input('id');
            $id_dato_lota = [];
            $img_borrar = [];

// Recopilar los archivos antiguos para eliminarlos
            foreach ($id_ as $id_lota) {
                array_push($id_dato_lota, $id_lota);
                $borrar_archivos = Datos_lotaip::select('archivo')
                    ->where('id_datos_lotaip', $id_lota)
                    ->first();
                if ($borrar_archivos) {
                    array_push($img_borrar, $borrar_archivos->archivo);
                }
            }

// Eliminar archivos antiguos en lotes
            $img_borrar = array_filter($img_borrar);
            if (!empty($img_borrar)) {
                foreach ($img_borrar as $img) {
                    if (Storage::disk('google')->exists($img)) {
                        Storage::disk('google')->delete($img);
                    }
                }
            }

// Obtener lista de archivos en Google Drive y asociar con la base de datos
            $dir = "/";
            $recursive = false;
            $archivo_cod = [];
            $contents = collect(Storage::disk("google")->listContents($dir, $recursive));
            foreach ($nombre_archivos as $archivo) {
                $fileid = $contents->where("type", "file")
                    ->where("filename", pathinfo($archivo, PATHINFO_FILENAME))
                    ->where("extension", pathinfo($archivo, PATHINFO_EXTENSION))
                    ->first();

if ($fileid) {
                    array_push($archivo_cod, $fileid["path"]);
                }
            }

// Verificar si el número de archivos coincide con el número de IDs
            if (count($archivo_cod) !== count($id_dato_lota)) {
                return response()->json(['error' => 'Hubo un problema al asociar los archivos con los registros.']);
            }

// Actualizar la base de datos con los nuevos archivos
            for ($i = 0; $i < count($archivo_cod); $i++) {
                $datos_lotaip = Datos_lotaip::find($id_dato_lota[$i]);
                $datos_lotaip->archivo = $archivo_cod[$i];
                $datos_lotaip->save();
            }

DB::commit();

return response()->json(['success' => true, 'message' => 'Actualización exitosa!', 'id_archivo' => $archivo_cod, 'ruta' => env('RUTA_DRIVE_VIEW'), 'ides' => $id_dato_lota]);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['error_validacion' => $e->errors()]);
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error: ' . $e->getMessage()]);
        }
    }

public function destroy($id, $ide)
    {
        try {
            $cantidad = 0;
            $nombre = Datos_lotaip::select('archivo')
                ->where('id_lotaip', $id)
                ->where('id_lotaipvigente', $ide)
                ->get();
            foreach ($nombre as $date) {
                if (Storage::disk('google')->exists($date->archivo))
                    $cantidad++;
            }
            if ($cantidad == 4) {
                foreach ($nombre as $date) {
                    Storage::disk('google')->delete($date->archivo);
                }
                DB::table('datos_lotaip')->where('id_lotaip', '=', $id)->where('id_lotaipvigente', '=', $ide)->delete();
                return response()->json(['success' => true, 'message' => 'Eliminación exitosa!']);
            } else
                return response()->json(['error' => 'Ha ocurrido un error: No se puedo encotrar los archivos']);
        } catch (\Exception $e) {
            return response()->json(['error' => 'Ha ocurrido un error: ' . $e->getMessage()]);
        } catch (QueryException $e) {
            return response()->json(['error' => 'Error en la base de datos: ' . $e->getMessage()]);
        }
    }
}