EVOLUTION-MANAGER

Edit File: crudrendicioncuenta.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Rendicion_cuenta;
use Illuminate\Support\Facades\DB;
use PHPUnit\Util\Json;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Log;
use App\Services\GoogleDriveService;
use Illuminate\Validation\ValidationException;
use Illuminate\Database\QueryException;

class crudrendicioncuenta extends Controller
{

public function index()
    {
        $anio = Rendicion_cuenta::selectraw('fecha as anio')
            ->orderBy('anio', 'desc')
            ->distinct()
            ->get();

$datos = Rendicion_cuenta::selectraw('fecha as anio, id_r_cuentas, titulo, nombre_archivo, orden')
            ->orderBy('anio', 'desc')
            ->orderBy('orden', 'asc')
            ->get();

return view('web-administrador-rendicion-de-cuentas/crudrendicioncuenta', 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-rendicion-de-cuentas/crear_rendisioncu", compact('anio_orden', 'anios'));
    }

public function crear_rendicion(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 = Rendicion_cuenta::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;

Rendicion_cuenta::create([
                'fecha' => $request->fecha,
                'titulo' => $request->titulo,
                'nombre_archivo' => $archivo_cod,
                'orden' => $nuevoOrden,
            ]);

DB::commit();
            return redirect()->route('crear-rendicion')->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_rendicion(Request $request)
    {
        DB::beginTransaction();
        try {
            $validatedData = $request->validate([
                'fecha' => 'required|max:4',
                'titulo' => 'required|min:10|max:260',
                'nombre_archivo' => 'required|file|max:10240|mimes:pdf',
            ], [
                '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.min' => 'El titulo debe tener mínimo 10 caracteres.',
                '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 rendicion
            $nuevoOrden = Rendicion_cuenta::where('fecha', $request->fecha)
                ->max('orden') + 1 ?? 1;

// Crear y guardar la nueva rendicion
            $rendicion = Rendicion_cuenta::create([
                'fecha' => $request->fecha,
                'titulo' => $request->titulo,
                'nombre_archivo' => $archivo_cod,
                'orden' => $nuevoOrden,
            ]);

DB::commit();
            return response()->json([
                'success' => true, 
                'message' => 'Rendición creada con éxito!', 
                'id' => $rendicion->id_r_cuentas, 
                'id_archivo' => $archivo_cod, 
                'ruta' => env('RUTA_DRIVE_VIEW'),
                'orden_archivo' => $nuevoOrden
            ]);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['errors' => $e->errors()]);
        } catch (QueryException $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 el nombre del archivo asociado a la rendición de cuentas
            $rendicion = Rendicion_cuenta::select('nombre_archivo', 'fecha', 'orden')
                ->where('id_r_cuentas', $id)
                ->first();

// Verificar si se encontró la rendición de cuentas
            if (!$rendicion) {
                return response()->json(['error' => 'Registro no encontrado']);
            }

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

// Eliminar el registro de la base de datos
                Rendicion_cuenta::where('id_r_cuentas', $id)->delete();

// Actualizar el orden de las rendiciones con la misma fecha
                Rendicion_cuenta::where('fecha', $rendicion->fecha)
                    ->where('orden', '>', $rendicion->orden)
                    ->decrement('orden');

DB::commit();

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

return response()->json(['success' => 'Eliminación exitosa!', 'datos' => $datos]);
            } else {
                DB::rollback(); // Revertir la transacción
                return response()->json(['error' => 'Documento no encontrado en almacenamiento']);
            }
        } catch (\Exception $e) {
            DB::rollback(); // Revertir la transacción en caso de error
            Log::error('Error al eliminar el registro: ' . $e->getMessage());
            return response()->json(['error' => 'Ha ocurrido un error, intentelo en otro momento']);
        }
    }

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

try {

$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 = Rendicion_cuenta::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 {
            $validatedData = $request->validate([
                'id.*' => 'required',
                'orden.*' => 'required|string|max:3',
            ]);

$id_rendicion = $request->input('id');
            $id_array = [];
            foreach ($id_rendicion as $id) {
                array_push($id_array, $id);
            }

$orden_rendicion = $request->input('orden');
            $orden_array = [];
            foreach ($orden_rendicion as $orden) {
                array_push($orden_array, $orden);
            }

for ($i = 0; $i < count($id_rendicion); $i++) {
                $cuentas = Rendicion_cuenta::find($id_rendicion[$i]);
                $cuentas->orden = $orden_array[$i];
                $cuentas->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) {
            DB::rollback();
            return response()->json(['error' => 'Error en la base de datos: ' . $e->getMessage()]);
        } catch (QueryException $e) {
            DB::rollback();
            return response()->json(['error' => 'Error en la base de datos: ' . $e->getMessage()]);
        }
    }
}