EVOLUTION-MANAGER

Edit File: crudboletin.php

<?php

namespace App\Http\Controllers;

use App\Info_imagen;
use Illuminate\Http\Request;
use App\Informativo;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Log;

class crudboletin extends Controller
{
    public function index()
    {
        $datosnoticias = Informativo::select('id_informativo', 'titulo', 'fecha')
            ->orderBy('fecha', 'desc')
            ->orderBy('id_informativo', 'desc')
            ->get();
        $cantidad = Informativo::selectraw('count(id_informativo) as cantidad')
            ->first();
        return view("web-administrador-noticias/crud-boletin", compact('datosnoticias', 'cantidad'));
    }

public function show_crear()
    {
        return view("web-administrador-noticias/crear_noticia");
    }

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

try {
            $validatedData = $request->validate([
                'titulo' => 'required|min:16|max:500',
                'contenido' => 'required|min:16|max:65000',
                'fecha' => 'required',
                'anio' => 'required|max:10',
                'mes' => 'required|max:10',
                'documento' => 'required|file|mimes:pdf|max:10240',
                'imagenes' => 'required|array',
                'imagenes.*' => 'required|file|mimes:jpg,png,jpeg',
                'orden.*' => 'required|max:3',
            ], [
                'titulo.required' => 'El titulo es obligatorio.',
                'titulo.max' => 'El titulo no puede tener más de 500 caracteres.',

'contenido.required' => 'El contenido es obligatorio.',
                'contenido.max' => 'El contenido no puede exceder los 65,000 caracteres.',

'fecha.required' => 'La fecha es obligatoria.',

'anio.required' => 'El año es obligatorio.',
                'anio.max' => 'El año no puede tener más de 10 caracteres.',

'mes.required' => 'El mes es obligatorio.',
                'mes.max' => 'El mes no puede tener más de 10 caracteres.',

'documento.required' => 'El documento es obligatorio.',
                'documento.file' => 'El documento debe ser un archivo.',
                'documento.mimes' => 'El documento debe ser un archivo PDF.',
                'documento.max' => 'El documento no puede superar los 10 MB.',

'imagenes.required' => 'Las imagenes son obligatoria.',
                'imagenes.*.required' => 'Las imagenes son obligatoria.',
                'imagenes.*.file' => 'Las imagenes debe ser un archivo.',
                'imagenes.*.mimes' => 'Las imagenes debe ser de tipo jpg, png o jpeg.',

'orden.*.required' => 'El campo de orden es obligatorio.',
                'orden.*.max' => 'El orden no puede tener más de 3 caracteres.',
            ]);

$file = $request->file("documento");
            $filename = time() . "-" . $file->getClientOriginalName();
            $fileContent = file_get_contents($file->getRealPath());

Storage::disk('google')->put($filename, $fileContent);

$dir = "/";
            $recursive = false;
            $archivo_cod = null;
            $contents = collect(Storage::disk("google")->listContents($dir, $recursive));
            $fileid = $contents->where("type", "file")
                ->where("filename", pathinfo($filename, PATHINFO_FILENAME))
                ->where("extension", pathinfo($filename, PATHINFO_EXTENSION))
                ->first();
            if ($fileid)
                $archivo_cod = $fileid["path"];

$informativo = new Informativo();
            $informativo->titulo = $request->titulo;
            $informativo->contenido = $request->contenido;
            $informativo->fecha = $request->fecha;
            $informativo->nombre_archivo = $archivo_cod;
            $informativo->anios = $request->anio;
            $informativo->mes = $request->mes;
            $informativo->save();

$id = $informativo->id_informativo;

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

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

foreach ($img_info as $docu) {
                $filename = time() . "-" . $docu->getClientOriginalName();
                // Almacenar el archivo en el disco de Google
                Storage::disk('imagenes')->put($filename, file_get_contents($docu->getRealPath()));
                array_push($nombre_archivos, $filename);
            }

for ($i = 0; $i < count($nombre_archivos); $i++) {
                $img_informativo = new Info_imagen();
                $img_informativo->nombre_archivo = $nombre_archivos[$i];
                $img_informativo->orden = $array_orden[$i];
                $img_informativo->id_informativo = $id;
                $img_informativo->save();
            }

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) {
            DB::rollback();
            Log::error('Ha ocurrido un error: ' . $e->getMessage());
            return response()->json(['error' => 'Ha ocurrido un error, intentolo en más tarde']);
        }
    }

public function destroy($id)
    {
        DB::beginTransaction();  // Inicia una transacción para asegurar atomicidad
        try {
            // Obtener el nombre del archivo del documento principal
            $nombre_docu = Informativo::where('id_informativo', $id)
                ->pluck('nombre_archivo')
                ->first();

// Obtener los nombres de las imágenes relacionadas
            $nombres_imagenes = Info_imagen::where('id_informativo', $id)
                ->pluck('nombre_archivo');

// Verificar y eliminar el archivo en Google Drive
            if (!$nombre_docu || !Storage::disk('google')->exists($nombre_docu)) {
                return response()->json(['error' => 'No se pudo completar la eliminación porque no se encontró el archivo del documento']);
            }

// Eliminar el archivo del documento
            Storage::disk('google')->delete($nombre_docu);

// Eliminar archivos de imágenes relacionados
            foreach ($nombres_imagenes as $nombre_imagen) {
                if (Storage::disk('imagenes')->exists($nombre_imagen)) {
                    Storage::disk('imagenes')->delete($nombre_imagen);
                } else {
                    Log::warning('Archivo de imagen no encontrado: ' . $nombre_imagen);
                }
            }

// Eliminar el registro en la base de datos
            DB::table('informativo')->where('id_informativo', '=', $id)->delete();

//actualizar cantidad de noticias
            $cantidad = Informativo::selectraw('count(id_informativo) as cantidad')
            ->first();

DB::commit();  // Confirma la transacción
            return response()->json(['success' => true, 'message' => 'Eliminación exitosa!', 'cantidad' => $cantidad]);
        } catch (\Exception $e) {
            DB::rollBack();  // Deshace los cambios en caso de error
            Log::error('Error al eliminar el informativo: ' . $e->getMessage());
            return response()->json(['error' => 'Ha ocurrido un error inesperado. Por favor, inténtelo de nuevo más tarde.']);
        }
    }

public function editar_noticia($id)
    {
        try {
            // $nombre_docu = Informativo::select('nombre_archivo')
            //     ->where('id_informativo', $id)
            //     ->first();
            // Obtener el registro de la noticia
            $nombre_docu     = Informativo::select('id_informativo', 'titulo', 'contenido', 'fecha', 'nombre_archivo')
                ->where('id_informativo', $id)
                ->firstOrFail();  // Lanza una excepción si no se encuentra

$filename = null;
            $fileid = $nombre_docu->nombre_archivo;
            if (Storage::disk('google')->exists($nombre_docu->nombre_archivo)) {
                $dir = "/";
                $recursive = false;
                $contents = collect(Storage::disk("google")->listContents($dir, $recursive));
                $file = $contents->where("path", $fileid)->first();
                if ($file) {
                    $filename = $file['filename'] . '.' . $file['extension'];
                }
            }

$noticias = Informativo::select('id_informativo', 'titulo', 'contenido', 'fecha')
                ->where('id_informativo', $id)
                ->get();

$imagenes = Info_imagen::select('id_info_imagenes', 'nombre_archivo', 'orden')
                ->orderBy('orden', 'asc')
                ->where('id_informativo', $id)
                ->get();

return view('web-administrador-noticias/editar-noticia', compact('noticias', 'imagenes', 'filename'));
        } catch (\Exception $e) {
            // Manejo de errores
            Log::error('Error al editar la noticia: ' . $e->getMessage());
            return redirect()->route('mostrar-boletin')->with('error', 'No se pudo encontrar la noticia.');
        }
    }

public function crear_editar_noticia(Request $request, $id)
    {

DB::beginTransaction();
        try {
            $validatedData = $request->validate([
                'titulo' => 'required|min:16|max:500',
                'contenido' => 'required|min:16|max:65000',
                'fecha' => 'required',
                'anio' => 'required|max:10',
                'mes' => 'required|max:10',
                'documento' => 'file|mimes:pdf|max:10240',
                'imagenes.*' => 'file|mimes:jpg,png,jpeg',
                'orden.*' => 'max:3',
                'eliminar_img.*',
                'imagen_nuevoorden.*',
                'orden_total.*',
            ]);

$archivo_cod = null;
            if ($request->hasFile("documento")) {
                $file = $request->file("documento");
                $filename = time() . "-" . $file->getClientOriginalName();
                $fileContent = file_get_contents($file->getRealPath());

Storage::disk('google')->put($filename, $fileContent);

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

$informativo = Informativo::find($id);
            $informativo->titulo = $request->titulo;
            $informativo->contenido = $request->contenido;
            $informativo->fecha = $request->fecha;
            if ($archivo_cod != null)
                $informativo->nombre_archivo = $archivo_cod;
            $informativo->anios = $request->anio;
            $informativo->mes = $request->mes;
            $informativo->save();

if ($request->hasFile("imagenes")) {
                $nombre_archivos = [];
                $img_info = $request->file('imagenes');

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

foreach ($img_info as $docu) {
                    $filename = time() . "-" . $docu->getClientOriginalName();
                    // Almacenar el archivo en el disco de Google
                    Storage::disk('imagenes')->put($filename, file_get_contents($docu->getRealPath()));
                    array_push($nombre_archivos, $filename);
                }

for ($i = 0; $i < count($nombre_archivos); $i++) {
                    $img_informativo = new Info_imagen();
                    $img_informativo->nombre_archivo = $nombre_archivos[$i];
                    $img_informativo->orden = $array_orden[$i];
                    $img_informativo->id_informativo = $id;
                    $img_informativo->save();
                }
            }

if ($request->filled('eliminar_img')) {
                $del_img = $request->input('eliminar_img');
                foreach ($del_img as $option) {
                    $delete_img = Info_imagen::find($option);
                    if ($delete_img) {
                        Storage::disk('imagenes')->delete($delete_img->nombre_archivo);
                        $delete_img->delete();
                    }
                }
            }

$ids_imagenes = $request->input('imagen_nuevoorden');
            $ordenes_imagenes = $request->input('orden_total');
            if (count($ids_imagenes) === count($ordenes_imagenes)) {
                foreach ($ids_imagenes as $index => $id_imagen) {
                    $imagen = Info_imagen::find($id_imagen);
                    if ($imagen) {
                        $imagen->orden = $ordenes_imagenes[$index];
                        $imagen->save();
                    }
                }
            }

DB::commit();

return response()->json(['success' => true, 'message' => 'Actualización exitosa!']);
        } catch (ValidationException $e) {
            DB::rollback();
            return response()->json(['error_validacion' => $e->errors()]);
        } catch (\Exception $e) {
            DB::rollback();
            return response()->json(['error' => 'Ha ocurrido un error: ' . $e->getMessage()]);
        } catch (QueryException $e) {
            DB::rollback();
            return response()->json(['error' => 'Error en la base de datos: ' . $e->getMessage()]);
        }
    }
}