EVOLUTION-MANAGER

Edit File: ccpdlotaip.php

<?php

namespace App\Http\Controllers\consejos_cantonales;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\ccpd_lotaip_anioModel;
use App\ccpd_lotaip_literalModel;
use App\ccpd_lotaip_mesModel;
use Carbon\Carbon;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;

class ccpdlotaip extends Controller
{
    public function index()
    {
        $anios = ccpd_lotaip_anioModel::all()->sortBy('anio');
        $meses = ccpd_lotaip_mesModel::all()->sortBy('orden');
        $literales = ccpd_lotaip_literalModel::all();
        
        $date = Carbon::now();
        $anioActual = $date->year;
        $inicio = 2020;
        $aniosa = ($anioActual - $inicio) + 1;
        $arrayAnios[] = $inicio;

for ($i = 0; $i < $aniosa; $i++) {
            # code...
            if ($inicio != 2012) {
                $arrayAnios[] = $inicio;
            }

$inicio++;
        };

return view('admin/consejo_cantonal/ccpd_lotaip_index', compact('anios', 'meses', 'literales', 'arrayAnios'));
    }

public function guardar_anio(Request  $request)
    {
        $lotaip_anio = ccpd_lotaip_anioModel::where("anio", "=", $request->anio)->first();
        if ($lotaip_anio == null) {
            $lotaip_anio = new ccpd_lotaip_anioModel();
            $lotaip_anio->anio = $request->anio;
            $lotaip_anio->save();
            $anios = ccpd_lotaip_anioModel::all()->sortBy('anio');
            return $anios;
        } else {
            return 0;
        }
    }

public function eliminarAnio($id)
    {
        $anio = ccpd_lotaip_anioModel::find($id);

try {
            $lotaip_mes = ccpd_lotaip_mesModel::where("ccpd_lotaip_anio_id", "=", $id)->get();
            if ($lotaip_mes != null) {
                foreach ($lotaip_mes as $key => $mes) {
                    $lotaip_literal = ccpd_lotaip_literalModel::where("ccpd_lotaip_mes_id", "=", $mes->id)->get();

if ($lotaip_literal != null) {
                        foreach ($lotaip_literal as $key => $literal) {
                            $literal->delete();
                        }
                        $mes->delete();
                    }
                }
            }
            $anio->delete();
            return 1;
        } catch (Exception $e) {
            return 0;
        }
    }

public function nuevo_mes_store(Request $request)
    {
        try {
            // Verificar si el mes ya existe para este año
            $mesExistente = ccpd_lotaip_mesModel::where('ccpd_lotaip_anio_id', $request->id_anio)
                ->where('mes', $request->mes)
                ->first();

if ($mesExistente) {
                return response()->json([
                    'success' => false,
                    'message' => 'Este mes ya existe para el año seleccionado'
                ]);
            }

// Crear el nuevo mes
            $lotaip_mes = new ccpd_lotaip_mesModel();
            $lotaip_mes->mes = $request->mes;
            $lotaip_mes->orden = $request->orden;
            $lotaip_mes->ccpd_lotaip_anio_id = $request->id_anio;
            $lotaip_mes->save();

// Determinar si usa nueva estructura (según tu lógica original)
            $nuevaEstructura = false;
            $anio = ccpd_lotaip_anioModel::find($request->id_anio);

$meses_aux = [
                'enero' => 1, 'febrero' => 2, 'marzo' => 3, 'abril' => 4,
                'mayo' => 5, 'junio' => 6, 'julio' => 7, 'agosto' => 8,
                'septiembre' => 9, 'octubre' => 10, 'noviembre' => 11, 'diciembre' => 12
            ];

$aux_mes = $meses_aux[strtolower($request->mes)];

if ($anio->anio >= 2023 && $aux_mes == 12) {
                $nuevaEstructura = true;
            } else if ($anio->anio >= 2024) {
                $nuevaEstructura = true;
            }

return response()->json([
                'success' => true,
                'mes' => [
                    'id' => $lotaip_mes->id,
                    'mes' => $lotaip_mes->mes,
                    'anio_id' => $lotaip_mes->ccpd_lotaip_anio_id,
                    'nueva_estructura' => $nuevaEstructura,
                    'anio' => $anio->anio // Para facilitar la actualización en el frontend
                ]
            ]);
        } catch (Exception $e) {
            Log::error("Error inesperado: " . $e->getMessage(), [
                'exception' => $e->getTraceAsString()
            ]);
            return response()->json([
                'success' => false,
                'message' => 'Error al guardar el mes '
            ]);
        }
    }

public function nuevo_literal_store(Request  $request)
    {
        ini_set('max_execution_time', 3000);
        $file = $request->file('file_transp');
        // $transparencia = lotaip_anio::join('lotaip_mes','lotaip_anio.id','=','lotaip_mes.lotaip_anio_id')->where("lotaip_mes.id",$request->id_mes)->first();
        $destinationPath = 'pdfs';
        try {

if ($file) {

$lotaip_literal = new lotaip_literal();
                $lotaip_literal->literal = $request->nombre_literal;
                $lotaip_literal->letra = $request->letra_literal;
                $lotaip_literal->lotaip_mes_id = $request->id_mes;
                $lotaip_literal->save();

$nombre_pdf = 'Literal-' . $request->letra_literal . '-' . $request->nombre_literal . '-' . $lotaip_literal->id . '.' . $file->getClientOriginalExtension();
                $path = Storage::putFileAs($destinationPath, $file, $nombre_pdf);
                $pdf = Storage::get($path);
                Storage::disk('google')->put($nombre_pdf, $pdf, 'public');
                Storage::delete($path);
                $url = Storage::disk('google')->url($nombre_pdf);
                // $url = Storage::url('file.jpg');

$lotaip_literal->archivo = $url;
                $lotaip_literal->nombre_archivo = $nombre_pdf;
                $lotaip_literal->save();

return $lotaip_literal;
            }
        } catch (Exception $e) {
            return 0;
        }
    }

public function generarLiterales($estructura, $mes_id)
    {
        try {
            $lotaip_mes = ccpd_lotaip_mesModel::find($mes_id);
            if (!$lotaip_mes) {
                return [
                    'status' => false,
                    'mensaje' => "No se encontró el mes con ID: $mes_id."
                ];
            }

if ($estructura != 1) {
                return [
                    'status' => false,
                    'mensaje' => "Estructura no válida. Solo se permite estructura 1."
                ];
            }

$rutaArchivo = 'estructura_lotaip/estructura2.json';
            $contenidoJson = Storage::disk('public')->get($rutaArchivo);
            $json_estructura = json_decode($contenidoJson, true);

if ($json_estructura === null) {
                return [
                    'status' => false,
                    'mensaje' => "El archivo JSON está mal formado o vacío."
                ];
            }

$creados = 0;
            $existentes = 0;

foreach ($json_estructura as $item) {
                $literal = ccpd_lotaip_literalModel::where("ccpd_lotaip_mes_id", $lotaip_mes->id)
                    ->where(function ($query) use ($item) {
                        $query->where("letra", $item["letra"])
                            ->orWhere("literal", "like", "%" . $item["literal"] . "%");
                    })
                    ->first();

if (!empty($literal)) {
                    $existentes++;
                }
            }

if ($existentes > 0) {
                return [
                    'status' => false,
                    'mensaje' => "Ya existen $existentes literal(es) para este mes. No se generaron nuevos."
                ];
            }

foreach ($json_estructura as $item) {
                ccpd_lotaip_literalModel::create([
                    'ccpd_lotaip_mes_id' => $lotaip_mes->id,
                    'literal' => $item["literal"],
                    'letra' => $item["letra"],
                ]);
                $creados++;
            }

return [
                'status' => true,
                'mensaje' => "Proceso completado. Se crearon $creados literal(es)."
            ];
        } catch (\Throwable $e) {
            Log::error("Error inesperado: " . $e->getMessage(), [
                'exception' => $e->getTraceAsString()
            ]);
            return [
                'status' => false,
                'mensaje' => "Ocurrió un error inesperado. Consulta el log para más detalles."
            ];
        }
    }

public function editarliteral($id)
    {
        $lotaip_literal = ccpd_lotaip_literalModel::find($id);
        return $lotaip_literal;
    }

public function nueva_estructura_store(Request $request, $estructura)
    {
        // Validación de los datos recibidos
        $validator = Validator::make($request->all(), [
            'id_literal' => 'required|exists:ccpd_lotaip_literal,id',
            'letra_literal' => 'required|string|max:10',
            'nombre_literal' => 'required|string',
            'link_conjunto_datos' => 'nullable|url|max:500',
            'link_metadatos' => 'nullable|url|max:500',
            'link_diccionario' => 'nullable|url|max:500',
        ]);

if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Error de validación',
                'errors' => $validator->errors()
            ], 422);
        }

try {
            // Buscar el literal a actualizar
            $lotaip_literal = ccpd_lotaip_literalModel::findOrFail($request->id_literal);

// Actualizar campos básicos
            $lotaip_literal->letra = $request->letra_literal;
            $lotaip_literal->literal = $request->nombre_literal;

// Actualizar los links (solo si se proporcionaron)
            if ($request->filled('link_conjunto_datos')) {
                $lotaip_literal->conjunto_datos = $request->link_conjunto_datos;
            }

if ($request->filled('link_metadatos')) {
                $lotaip_literal->metadatos = $request->link_metadatos;
            }

if ($request->filled('link_diccionario')) {
                $lotaip_literal->diccionario = $request->link_diccionario;
            }

// Guardar los cambios
            $lotaip_literal->save();

// Respuesta exitosa
            return response()->json([
                'success' => true,
                'message' => 'Literal actualizado correctamente',
                'data' => [
                    'id' => $lotaip_literal->id,
                    'letra' => $lotaip_literal->letra,
                    'literal' => $lotaip_literal->literal,
                    'archivo' => $lotaip_literal->archivo,
                    'conjunto_datos' => $lotaip_literal->conjunto_datos,
                    'metadatos' => $lotaip_literal->metadatos,
                    'diccionario' => $lotaip_literal->diccionario
                ]
            ]);
        } catch (\Exception $e) {
            Log::error("Error inesperado: " . $e->getMessage(), [
                'exception' => $e->getTraceAsString()
            ]);
            // Manejo de errores
            return response()->json([
                'success' => false,
                'message' => 'Error al actualizar el literal'
            ]);
        }
    }

public function vaciarLinksLiteral($id)
    {
        try {
            $lotaip_literal = ccpd_lotaip_literalModel::findOrFail($id);
            // Vaciar los campos de links
            $lotaip_literal->update([
                'conjunto_datos' => null,
                'metadatos' => null,
                'diccionario' => null
            ]);
            return response()->json([
                'success' => true,
                'message' => 'Los links del literal han sido eliminados',
                'data' => [
                    'id' => $lotaip_literal->id,
                    'conjunto_datos' => null,
                    'metadatos' => null,
                    'diccionario' => null
                ]
            ]);
        } catch (Exception $e) {
            Log::error("Error al vaciar links: " . $e->getMessage(), [
                'exception' => $e->getTraceAsString()
            ]);
            return response()->json([
                'success' => false,
                'message' => 'Error al eliminar los links del literal'
            ]);
        }
    }

public function eliminarMes($id)
    {
        try {
            $lotaip_mes = ccpd_lotaip_mesModel::find($id);

if (!$lotaip_mes) {
                return response()->json([
                    'success' => false,
                    'message' => 'El mes no existe.',
                ], 404);
            }

// Elimina los literales relacionados
            ccpd_lotaip_literalModel::where("ccpd_lotaip_mes_id", $lotaip_mes->id)->delete();

// Elimina el mes
            $lotaip_mes->delete();

return response()->json([
                'success' => true,
                'message' => 'El mes fue eliminado correctamente',
            ]);
        } catch (Exception $e) {
            Log::error("Error al vaciar links: " . $e->getMessage(), [
                'exception' => $e->getTraceAsString()
            ]);
            return response()->json([
                'success' => false,
                'message' => 'Error al eliminar el mes'
            ]);
        }
    }
}