EVOLUTION-MANAGER

Edit File: crudresoluciones.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Resolucion;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Storage;
use Illuminate\Validation\ValidationException;
use Illuminate\Database\QueryException;
use Illuminate\Support\Facades\Log;

class crudresoluciones extends Controller
{
    public function index()
    {
        // Obtiene los años únicos ordenados de las resoluciones
        $anio = Resolucion::selectraw('fecha as anio')
            ->distinct()
            ->orderBy('anio', 'desc')
            ->get();

// Obtiene los datos de las resoluciones, ordenados por año y orden
        $datos = Resolucion::selectraw('fecha as anio, id_resoluciones, titulo, nombre_archivo, orden')
            ->orderBy('anio', 'desc')
            ->orderBy('orden', 'asc')
            ->get();

// Retorna la vista con los datos necesarios
        return view('web-administrador-resoluciones/crudresoluciones', compact('anio', 'datos'));
    }

public function show_crear()
    {
        //enviar años iniciando de 2023 hasta el año actual del servidor
        $anioInicio = 2023;
        $anioActual = date('Y');
        $anios = range($anioInicio, $anioActual);

return view("web-administrador-resoluciones/crear_resoluciones", compact('anios'));
    }

public function crear_resolucion(Request $request)
    {
        DB::beginTransaction();
        try {
            $validacion = Validator::make($request->all(), [
                'fecha' => ['required', 'max:4'],
                'titulo' => ['required', 'max:260'],
                'nombre_archivo' => ['required', 'file', 'mimes:pdf', 'max:10240'],
            ], [
                'fecha.required' => 'La fecha es obligatoria.',
                'fecha.max' => 'La fecha no puede tener más de 4 caracteres.',
                'titulo.required' => 'El titulo es obligatorio.',
                'titulo.max' => 'El título no puede tener más de 260 caracteres.',
                'nombre_archivo.required' => 'El archivo es obligatorio.',
                'nombre_archivo.file' => 'El archivo debe ser un documento válido.',
                'nombre_archivo.mimes' => 'El archivo debe ser un documento PDF.',
                'nombre_archivo.max' => 'El archivo no puede ser mayor a 10 MB.',
            ]);

if ($validacion->fails()) {
                return back()->withErrors($validacion)->withInput();
            }

// Manejo del archivo
            $archivo_cod = null; // Maneja el caso en el que no se encuentra el archivo
            $file = $request->file('nombre_archivo');
            $filename = time() . '-' . $file->getClientOriginalName();
            $fileContent = file_get_contents($file->getRealPath());

// Sube el archivo a Google Drive
            Storage::disk('google')->put($filename, $fileContent);

// Obtén el contenido de los archivos en Google Drive
            $dir = '/';
            $recursive = false;
            $contents = collect(Storage::disk('google')->listContents($dir, $recursive));

// Busca el archivo por nombre y extensión
            $fileid = $contents->where('type', 'file')
                ->where('filename', pathinfo($filename, PATHINFO_FILENAME))
                ->where('extension', pathinfo($filename, PATHINFO_EXTENSION))
                ->first();

// Obtén el ID del archivo
            if ($fileid)
                $archivo_cod = $fileid['path']; // Aquí estás obteniendo el ID del archivo

// Buscar el orden máximo para la fecha ingresada
            $maxOrden = Resolucion::where('fecha', $request->fecha)
                ->max('orden');

// Incrementar el orden en uno o si es el primer registro tomar el orden 1
            $nuevoOrden = $maxOrden !== null ? $maxOrden + 1 : 1;

// Crear y guardar el nuevo registro
            Resolucion::create([
                'fecha' => $request->fecha,
                'titulo' => $request->titulo,
                'nombre_archivo' => $archivo_cod,
                'orden' => $nuevoOrden,
            ]);

DB::commit();
            return redirect()->route('crear-resolucion')->with('status', 'Creación exitosa!');
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return back()->withErrors(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }

public function agregar_resolucion(Request $request)
    {
        DB::beginTransaction();
        try {
            // Validación de la solicitud
            $validatedData = $request->validate([
                'fecha' => 'required|string|max:4',
                'titulo' => 'required|string|max:260',
                'nombre_archivo' => 'required|file|mimes:pdf|max:10240',
            ], [
                'fecha.required' => 'La fecha es obligatoria.',
                'fecha.max' => 'La fecha no puede tener más de 4 caracteres.',
                'titulo.required' => 'El titulo es obligatorio.',
                'titulo.max' => 'El titulo no puede tener más de 260 caracteres.',
                'nombre_archivo.required' => 'El archivo es obligatorio.',
                'nombre_archivo.file' => 'El archivo debe ser un documento válido.',
                'nombre_archivo.mimes' => 'El archivo debe ser un documento PDF.',
                'nombre_archivo.max' => 'El archivo no puede ser mayor a 10 MB.',
            ]);

// Manejo del archivo
            $file = $request->file("nombre_archivo");
            $filename = time() . "-" . $file->getClientOriginalName();
            Storage::disk('google')->put($filename, file_get_contents($file->getRealPath()));

// Obtén el ID del archivo en Google Drive
            $contents = collect(Storage::disk("google")->listContents("/", false));
            $archivo_cod = optional($contents->where("type", "file")
                ->where("filename", pathinfo($filename, PATHINFO_FILENAME))
                ->where("extension", pathinfo($filename, PATHINFO_EXTENSION))
                ->first())['path'];

// Determina el nuevo orden para la resolución
            $nuevoOrden = Resolucion::where('fecha', $request->fecha)
                ->max('orden') + 1 ?? 1;

// Crear y guardar la nueva resolución
            $resolucion = Resolucion::create([
                'fecha' => $request->fecha,
                'titulo' => $request->titulo,
                'nombre_archivo' => $archivo_cod,
                'orden' => $nuevoOrden,
            ]);

DB::commit();
            return response()->json([
                'success' => true,
                'message' => 'Resolución creada con éxito!',
                'id' => $resolucion->id_resoluciones,
                'id_archivo' => $archivo_cod,
                'ruta' => env('RUTA_DRIVE_VIEW'),
                'orden_archivo' => $nuevoOrden
            ]);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['errors' => $e->errors()]);
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }

public function destroy($id)
    {
        DB::beginTransaction();
        try {
            // Obtener la resolución que se va a eliminar, incluyendo el campo 'fecha' y 'orden'
            $resolucion = Resolucion::select('nombre_archivo', 'fecha', 'orden')
                ->where('id_resoluciones', $id)
                ->first();

if (!$resolucion) {
                return response()->json(['error' => 'Resolución no encontrada.']);
            }

// Verificar si el archivo existe en Google Drive y eliminarlo
            if (Storage::disk('google')->exists($resolucion->nombre_archivo)) {
                Storage::disk('google')->delete($resolucion->nombre_archivo);

// Eliminar la resolución de la base de datos
                Resolucion::where('id_resoluciones', $id)->delete();

// Actualizar el orden de las resoluciones con la misma fecha
                Resolucion::where('fecha', $resolucion->fecha)
                    ->where('orden', '>', $resolucion->orden)
                    ->decrement('orden');
                    
                DB::commit();

// Obtiene los datos de las resoluciones, ordenados por año y orden
                $datos = Resolucion::selectraw('fecha as anio, id_resoluciones, titulo, nombre_archivo, orden')
                    ->orderBy('anio', 'desc')
                    ->orderBy('orden', 'asc')
                    ->get();

return response()->json(['success' => 'Eliminación exitosa!', 'datos' => $datos]);
            } else {
                return response()->json(['error' => 'No se encontró el documento almacenado.']);
            }
        } catch (\Exception $e) {
            DB::rollback();
            Log::error('Algo salió mal: ' . $e->getMessage());
            return response()->json(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }

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

try {
            // Validación de datos
            $validatedData = $request->validate([
                'titulo' => 'required|min:10|max:260',
                'nombre_archivo' => 'file|max:10240|mimes:pdf',
                'id' => 'required',
            ], [
                'titulo.required' => 'El titulo es obligatorio.',
                'titulo.min' => 'El titulo debe tener al menos 10 caracteres.',
                'titulo.max' => 'El titulo no puede tener más de 260 caracteres.',
                'nombre_archivo.file' => 'El archivo debe ser un archivo válido.',
                'nombre_archivo.max' => 'El archivo no puede ser mayor a 10 MB.',
                'nombre_archivo.mimes' => 'El archivo debe ser un documento PDF.',
                'id.required' => 'El ID es obligatorio.',
            ]);

$cuentas = Resolucion::findOrFail($request->id);
            $cuentas->titulo = $request->input('titulo');

// Si se sube un nuevo archivo
            if ($request->hasFile('nombre_archivo')) {
                $file = $request->file('nombre_archivo');
                $filename = time() . '-' . $file->getClientOriginalName();
                $fileContent = file_get_contents($file->getRealPath());

$nombre = $cuentas->nombre_archivo;

// Eliminar el archivo anterior si existe
                if (Storage::disk('google')->exists($nombre)) {
                    Storage::disk('google')->delete($nombre);
                } else {
                    return response()->json(['error' => 'Error al actualizar, no se encontró el archivo antiguo a reemplazar']);
                }

// Subir el nuevo archivo
                Storage::disk('google')->put($filename, $fileContent);

// Obtener la ruta del nuevo archivo
                $contents = collect(Storage::disk("google")->listContents("/", false));
                $fileid = $contents->where("type", "file")
                    ->where("filename", pathinfo($filename, PATHINFO_FILENAME))
                    ->where("extension", pathinfo($filename, PATHINFO_EXTENSION))
                    ->first();

$cuentas->nombre_archivo = $fileid ? $fileid["path"] : null;
            }

$cuentas->save();

DB::commit();
            return response()->json(['success' => true, 'message' => 'Cambios guardados con éxito!', 'id_archivo' => $cuentas->nombre_archivo, 'ruta' => env('RUTA_DRIVE_VIEW')]);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['errors' => $e->errors()]);
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }

public function re_ordenar(Request $request)
    {
        DB::beginTransaction();
        try {
            // Validar la entrada del usuario
            $validatedData = $request->validate([
                'id.*' => 'required',
                'orden.*' => 'required|string|max:3',
            ]);

// Obtener los arrays de IDs y órdenes directamente desde la solicitud
            $id_resoluciones = $request->input('id');
            $ordenes = $request->input('orden');

// Actualizar el orden de cada resolución
            foreach ($id_resoluciones as $index => $id) {
                $resolucion = Resolucion::find($id);
                $resolucion->orden = $ordenes[$index];
                $resolucion->save();
            }

DB::commit();
            return response()->json(['success' => true, 'message' => 'Re-ordenado con éxito!']);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['errors' => $e->errors()]);
        } catch (\Exception $e) {
            Log::error('Algo salió mal: ' . $e->getMessage());
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }
}