Ejercicios Prácticos: Bases De Datos Para Tu EPortfolio

¡Qué onda, gente! Si estáis aquí, es porque estáis listos para llevar vuestro ePortfolio al siguiente nivel, ¿verdad? Hasta ahora, hemos estado montando la estructura y familiarizándonos con algunas bases, pero, seamos sinceros, un proyecto web serio sin una base de datos es como un coche sin motor: puede que tenga buena pinta, pero no te lleva a ningún lado. En esta serie de ejercicios, vamos a sumergirnos de lleno en el fascinante mundo de la gestión de bases de datos dentro de vuestro proyecto de ePortfolio, usando las potentes herramientas que nos ofrece Laravel. Prepárense porque vamos a aprender a configurar, migrar, modelar y llenar de datos nuestras tablas, para que vuestro ePortfolio no solo se vea genial, sino que también sea dinámico, robusto y, lo más importante, ¡funcional! Vamos a currar con la configuración, las migraciones, los modelos y las semillas, para luego ver cómo integrar todo esto en vuestros controladores y vistas. ¿Listos para darle caña a esas bases de datos? ¡Pues, adelante!

Ejercicio 1 - Configuración y Migraciones de la Base de Datos: ¡Poniendo los Cimientos!

El primer paso, y super crucial, es asegurarnos de que nuestra base de datos esté configurada correctamente. No hay nada más frustrante que empezar a desarrollar y que falle por algo tan básico como la conexión a la base de datos, ¿verdad? Por eso, vamos a revisar y preparar todo para que funcione como la seda. Nuestro objetivo principal en este ejercicio es doble: primero, confirmar que la conexión de nuestro proyecto Laravel con la base de datos es perfecta, y segundo, usar las migraciones para crear las tablas necesarias de una manera controlada y profesional. Las migraciones son como el control de versiones de vuestra base de datos; nos permiten definir el esquema de las tablas de forma programática, lo que facilita enormemente el trabajo en equipo y el despliegue de la aplicación. ¡Es una herramienta que os va a salvar la vida muchas veces, creedme!

Para empezar, abrid ese archivo .env en la raíz de vuestro proyecto. Aquí es donde se guardan las configuraciones más importantes, y claro, ¡la de la base de datos es una de ellas! Tenéis que verificar que las variables relacionadas con la base de datos (DB_CONNECTION, DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, DB_PASSWORD) estén apuntando a vuestra base de datos MariaDB con el nombre eportfolio y las credenciales que hayáis establecido. Por ejemplo, aseguraos de que DB_DATABASE=eportfolio y que DB_USERNAME y DB_PASSWORD coincidan con los de vuestro sistema. Un pequeño error aquí puede causar muchos quebraderos de cabeza, así que tomadlo con calma y revisad bien.

Una vez revisado el .env, es hora de ir a PHPMyAdmin o la herramienta de gestión de bases de datos que utilicéis. Aquí, debemos confirmar que el usuario eportfolio y la base de datos eportfolio existan y tengan los permisos adecuados. Si no están creados, ¡este es el momento de hacerlo! Es fundamental que el usuario tenga privilegios para crear, leer, actualizar y eliminar tablas dentro de la base de datos eportfolio para que vuestra aplicación pueda interactuar sin problemas. Esto asegura que Laravel tenga vía libre para hacer su magia.

Con la configuración lista y la base de datos preparada, abrimos un terminal en la carpeta de nuestro proyecto y ejecutamos el comando mágico: php artisan migrate. Este comando toma todas las migraciones que ya tengamos definidas en el directorio database/migrations y las ejecuta, creando o modificando las tablas en nuestra base de datos. Si todo va bien, veréis un mensaje de éxito. Si os sale algún error, ¡tranquilos! Lo más probable es que sea por algo en el fichero .env que no concuerda con PHPMyAdmin o que el servidor web necesita un reinicio. Un truquito es probar a reiniciar el servidor o el terminal y volver a intentar el comando.

Ahora viene lo bueno: vamos a crear las nuevas tablas para nuestro ePortfolio. Necesitamos tablas para familias_profesionales, ciclos_formativos, resultados_aprendizaje y criterios_evaluacion. Cada una con su modelo y seeder correspondiente, y las vamos a generar en un orden específico para manejar las relaciones. Para crear una nueva migración, utilizaremos el comando de Artisan: php artisan make:migration create_[nombre_tabla]_table. Por ejemplo, para las familias profesionales, sería php artisan make:migration create_familias_profesionales_table. Es importantísimo renombrar el archivo generado con un formato específico: [año]_[mes]_[día]_00000n_create_[tabla]_table.php, donde n es el número de orden de nuestra lista (1 para familias_profesionales, 2 para ciclos_formativos, y así sucesivamente). Esto ayuda a mantener el orden de ejecución y a evitar problemas con dependencias.

Después de crear el archivo de migración, hay que editarlo para añadir los campos necesarios. ¿Y de dónde sacamos esos campos? ¡Fácil! La documentación de la API de vuestro ePortfolio, en la sección Schemas, tiene todos los detalles. Buscad el esquema Store Request del recurso que estéis trabajando (por ejemplo, Store Familia Profesional Request para familias_profesionales). Allí veréis los nombres de los campos, sus tipos de datos y si son requeridos o no. Dentro del método up() de la migración, usaréis Schema::create() para definir la estructura de la tabla, especificando string, integer, text, timestamp, foreignId para claves foráneas, y nullable() o default() según lo necesitéis. ¡No olvidéis que la clave primaria id y los timestamps suelen venir ya por defecto con $table->id() y $table->timestamps()!

Una práctica excelente y fundamental es implementar siempre el método down() en vuestras migraciones. Este método debe deshacer lo que hizo el método up(). En nuestro caso, como en up() estamos creando una tabla, en down() simplemente la eliminaremos con Schema::dropIfExists('nombre_tabla'). Esto es clave si alguna vez necesitáis revertir una migración (por ejemplo, con php artisan migrate:rollback). Una vez que hayáis definido todos los campos para cada una de las tablas, volved a ejecutar php artisan migrate. ¡Veréis cómo vuestras nuevas tablas aparecen en PHPMyAdmin con todos los campos definidos! ¡Y voilà, ya tenéis los cimientos de vuestra base de datos listos y en orden!

Ejercicio 2 - Modelado de Datos: El Corazón de tu ePortfolio en Acción

Muy bien, chavales, ya tenemos nuestras tablas bien configuradas en la base de datos gracias a las migraciones. Ahora, ¿cómo interactuamos con ellas de una manera elegante, sencilla y potente? Aquí es donde entran en juego los Modelos de Datos de Laravel, que utilizan el ORM (Object-Relational Mapping) Eloquent. Imaginaos que los modelos son vuestros intermediarios VIP entre vuestra aplicación y la base de datos. En vez de escribir sentencias SQL complicadas y propensas a errores, interactuáis con objetos PHP que representan vuestras tablas. ¡Es como hablar con la base de datos en vuestro propio idioma! Este ejercicio se centra en crear estos modelos para cada una de las tablas que definimos en el Ejercicio 1, asegurándonos de que Eloquent sepa exactamente cómo conectar cada modelo con su tabla correspondiente. Esto no solo simplifica la lectura y escritura de datos, sino que también nos permite definir relaciones entre las tablas (uno a muchos, muchos a muchos) de forma intuitiva, sentando las bases para una aplicación mucho más inteligente y conectada. La clave de un buen desarrollo en Laravel a menudo reside en unos modelos bien estructurados y correctamente configurados.

Para crear un modelo, Laravel nos ofrece otro comando de Artisan que es una maravilla: php artisan make:model NombreModelo. Por ejemplo, para la tabla familias_profesionales, crearíamos el modelo FamiliaProfesional. Este comando genera un archivo PHP en el directorio app/Models/ con la estructura básica de una clase. Una vez creado, abrid este fichero. Dentro, veréis que la clase FamiliaProfesional (o el nombre que le hayáis dado) ya extiende de Illuminate\Database\Eloquent\Model. Esto es esencial, ya que le otorga todas las superpoderes de Eloquent para interactuar con la base de datos. Si por alguna razón el nombre de la tabla no es el plural en inglés del modelo (por ejemplo, FamiliaProfesional y familias_profesionales), Eloquent es lo suficientemente inteligente para intentar adivinarlo. Pero, a veces, es mejor ser explícitos. Para esos casos, simplemente añadimos una propiedad $table dentro de nuestro modelo, indicando el nombre exacto de la tabla. Por ejemplo:

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class FamiliaProfesional extends Model
{
    use HasFactory;

    protected $table = 'familias_profesionales';

    // Otros atributos como $fillable o relaciones
}

Esta pequeña línea protected $table = '...'; es muy útil cuando los nombres de vuestras tablas no siguen las convenciones estándar de Laravel (que generalmente espera que una tabla users tenga un modelo User). Aseguraos de hacer esto para cada uno de vuestros modelos: FamiliaProfesional, CicloFormativo, ResultadoAprendizaje y CriterioEvaluacion. No os preocupéis si al principio os parece un poco tedioso, pero es una buena práctica que os ahorrará problemas a largo plazo y hará vuestro código mucho más claro y mantenible. Además de especificar el nombre de la tabla, aunque no se pide explícitamente en el enunciado, es una excelente costumbre definir las propiedades $fillable o $guarded en vuestros modelos. Esto controla qué campos pueden ser asignados masivamente (cuando creáis o actualizáis un registro con un array de datos), lo que es una medida de seguridad importante para evitar asignaciones de datos no deseadas.

Los modelos no son solo una forma de interactuar con las tablas; son el lugar ideal para definir las relaciones entre ellas. Por ejemplo, una FamiliaProfesional puede tener muchos CiclosFormativos, y un CicloFormativo tendrá muchos ResultadosAprendizaje, que a su vez tendrán muchos CriteriosEvaluacion. Estas relaciones se definen como métodos dentro del modelo (por ejemplo, hasMany(), belongsTo(), etc.), lo que permite a Eloquent cargar datos relacionados de forma perezosa o ansiosa, optimizando las consultas a la base de datos. Aunque no es parte directa de este ejercicio, tener esto en mente os ayudará a construir una arquitectura de datos más coherente y potente en el futuro de vuestro ePortfolio. Con los modelos ya creados y configurados para cada tabla, vuestra aplicación está lista para empezar a interactuar con los datos de una forma mucho más abstracta y eficiente. ¡Felicidades, porque ya domináis la base del ORM de Laravel!

Ejercicio 3 - Semillas: Llenando tu Base de Datos con Datos Reales para tu ePortfolio

¡Genial! Ya tenemos la estructura de nuestra base de datos definida con las migraciones y los modelos listos para interactuar con esas tablas. Pero, ¿qué es una base de datos sin datos? ¡Pues, una base de datos vacía, claro! Y nadie quiere ver una página en blanco en su ePortfolio, ¿verdad? Por eso, en este ejercicio, nos vamos a enfocar en las semillas (o seeders). Las semillas son un mecanismo super útil en Laravel para rellenar vuestra base de datos con datos de prueba o datos iniciales de una forma automatizada y controlada. Esto es ideal tanto para el desarrollo, cuando necesitáis tener datos para probar nuevas funcionalidades, como para la puesta en marcha de la aplicación, para que esta arranque con información esencial. Vamos a aprender a crear nuestros propios seeders y a utilizarlos para poblar todas esas tablas que hemos estado creando. ¡Es el momento de darle vida a vuestra base de datos con información real y relevante para vuestro ePortfolio!

El punto de partida para todas nuestras semillas es el archivo database/seeders/DatabaseSeeder.php. Este archivo contiene la clase principal DatabaseSeeder, cuyo método run() es el encargado de orquestar la ejecución de todos los demás seeders que creemos. Pensad en él como el director de orquesta de vuestros datos. Antes de llamar a vuestros seeders personalizados, veréis unas líneas muy importantes: Model::unguard(); y Schema::disableForeignKeyConstraints();. Estas líneas son vitales. Model::unguard() desactiva la protección contra la asignación masiva de campos temporalmente, lo que nos permite insertar datos fácilmente sin preocuparnos por los campos $fillable o $guarded en los modelos. Y Schema::disableForeignKeyConstraints(), como su nombre indica, deshabilita temporalmente las restricciones de clave foránea, lo cual es increíblemente útil cuando estáis insertando datos en tablas que tienen relaciones entre sí, ya que os permite insertar registros en cualquier orden sin que salten errores por dependencias. ¡No olvidéis que estas protecciones deben ser reestablecidas al final con Model::reguard(); y Schema::enableForeignKeyConstraints();!

Para cada una de las tablas que creamos, vamos a necesitar un fichero semilla específico. Podemos crearlos con php artisan make:seeder NombreSeederTableSeeder. Así tendremos FamiliasProfesionalesTableSeeder, CiclosFormativosTableSeeder, ResultadosAprendizajeTableSeeder y CriteriosEvaluacionTableSeeder. Una vez creados, debéis llamarlos desde el método run() de vuestro DatabaseSeeder principal usando $this->call(NombreSeederTableSeeder::class);. Aseguraos de que el orden de llamada sea el correcto, siguiendo las dependencias de clave foránea. Por ejemplo, las familias profesionales deben existir antes que los ciclos formativos.

// Dentro de database/seeders/DatabaseSeeder.php

public function run(): void
{
    Model::unguard();
    Schema::disableForeignKeyConstraints();

    $this->call(FamiliasProfesionalesTableSeeder::class);
    $this->call(CiclosFormativosTableSeeder::class);
    $this->call(ResultadosAprendizajeTableSeeder::class);
    $this->call(CriteriosEvaluacionTableSeeder::class);

    Model::reguard();
    Schema::enableForeignKeyConstraints();
}

Ahora, el meollo del asunto: cómo rellenar los datos. El contenido para FamiliasProfesionalesTableSeeder ya está disponible en los materiales, así que podéis copiarlo y pegarlo en vuestro archivo de seeder. Para los ResultadosAprendizaje y CriteriosEvaluacion, tenéis ejemplos proporcionados en el enunciado. Dentro del método run() de cada seeder específico, usaréis el modelo Eloquent para crear los registros. Por ejemplo, para ResultadosAprendizajeTableSeeder, podríais hacer algo como:

// Dentro de database/seeders/ResultadosAprendizajeTableSeeder.php

use App\Models\ResultadoAprendizaje;
use Illuminate\Database\Seeder;

class ResultadosAprendizajeTableSeeder extends Seeder
{
    public function run(): void
    {
        ResultadoAprendizaje::create([
            'ciclo_formativo_id' => 1, // Asumiendo que existe un ciclo formativo con ID 1
            'codigo' => 'RA1',
            'descripcion' => 'Selecciona las arquitecturas y tecnologías de programación web en entorno servidor, analizando sus capacidades y características propias.'
        ]);
        // Repetir para los demás resultados de aprendizaje
    }
}

Y similarmente para CriteriosEvaluacionTableSeeder, asegurándoos de vincular cada criterio a su resultado_aprendizaje_id correspondiente. Un tip importante: recordad incluir siempre el use App\Models\NombreModelo; en la parte superior de vuestros archivos seeder, de lo contrario, Laravel no sabrá dónde encontrar vuestros modelos y os dará el error Fatal error: Class '...' not found. ¡Aseguraos de definir correctamente los campos que son claves foráneas para que los datos se relacionen adecuadamente!

Finalmente, una vez que hayáis configurado todos vuestros seeders y llamado a cada uno desde DatabaseSeeder, abrid vuestro terminal y ejecutad: php artisan db:seed. Este comando ejecutará el DatabaseSeeder principal, que a su vez llamará a todos vuestros seeders personalizados. ¡Id a PHPMyAdmin y comprobad que todas vuestras tablas estén llenas de datos! Veréis cómo de repente vuestras tablas cobran vida con toda la información que habéis preparado. Esto no solo es satisfactorio, sino que también es un paso crucial para poder empezar a desarrollar las funcionalidades de vuestro ePortfolio con datos reales. ¡Enhorabuena, ya tenéis vuestra base de datos lista para ser usada por vuestra aplicación!

Ejercicio 4 - Uso de la Base de Datos: Tus Controladores y Vistas Cobran Vida en el ePortfolio

¡Fantástico, equipo! Hemos recorrido un largo camino: hemos configurado nuestra base de datos, implementado las migraciones para estructurar nuestras tablas, creado los modelos para interactuar con ellas de forma elegante y, finalmente, llenado esas tablas con datos reales usando los seeders. Ahora es el momento de la verdad, el momento de que todo ese trabajo cobre sentido y podamos ver cómo nuestra aplicación ePortfolio empieza a mostrar y gestionar esos datos. Este ejercicio es crucial porque es donde unimos el backend con el frontend. Dejaremos de lado los arrays estáticos y empezaremos a obtener la información directamente de nuestra base de datos a través de los controladores y a mostrarla de forma dinámica en nuestras vistas. ¡Preparaos para que vuestro ePortfolio deje de ser una maqueta estática y se convierta en una aplicación web interactiva y viva!

Para poder utilizar los datos que ya tenemos en la base de datos, vamos a retomar la estructura MVC (Modelo-Vista-Controlador) que ya conocéis. Anteriormente, es posible que vuestros controladores estuvieran trabajando con datos almacenados en arrays en memoria. ¡Pues eso se acabó! Ahora, esos mismos controladores van a interactuar con los modelos de Eloquent para extraer la información de la base de datos. Tendréis que adaptar los controladores que ya teníais para gestionar los recursos (Familias Profesionales, Ciclos Formativos, etc.). Esto implica modificar los métodos como getIndex(), getShow() y getEdit() para que, en lugar de buscar en un array, hagan consultas a la base de datos usando vuestros modelos.

Empecemos con getIndex(). Este método es el encargado de mostrar un listado de todos los elementos de un recurso. Antes, probablemente devolvía un array completo. Ahora, utilizando vuestro modelo (FamiliaProfesional, CicloFormativo, etc.), simplemente llamaremos a NombreModelo::all(). Por ejemplo, $familias = FamiliaProfesional::all();. Este comando recupera todas las filas de la tabla familias_profesionales y las devuelve como una colección de objetos FamiliaProfesional. Luego, esta colección se pasa a la vista (view('familias.index', ['familias' => $familias])) para que pueda iterar sobre ella y mostrar los datos. ¡Así de fácil es obtener todos los datos de una tabla con Eloquent!

Para getShow(), el método que muestra los detalles de un único elemento, la cosa se pone aún más interesante. Este método recibe un id por parámetro, y nuestro objetivo es encontrar el registro específico con ese id en la base de datos. Aquí es donde brilla NombreModelo::findOrFail($id). Por ejemplo, $familia = FamiliaProfesional::findOrFail($id);. El método findOrFail() es super útil porque, si encuentra el registro con el id especificado, lo devuelve; pero si no lo encuentra, automáticamente lanzará una excepción que Laravel convertirá en una página de error 404 (Not Found). ¡Esto es mucho mejor que tener que comprobar manualmente si el resultado existe! La instancia del modelo recuperada se pasa a la vista (view('familias.show', ['familia' => $familia])). Y lo mismo aplica para getEdit(). Este método también recibirá un id y necesitará obtener los datos del elemento a editar para rellenar el formulario. Usaremos NombreModelo::findOrFail($id) de la misma manera que en getShow(), para asegurar que estamos editando un registro existente y para pasar ese objeto a la vista de edición (view('familias.edit', ['familia' => $familia])).

Un recordatorio importante: al igual que con los seeders, si os encontráis con un error del tipo Class 'App\Http\Controllers\...' not found cuando intentéis usar vuestros modelos en los controladores, es casi seguro que se os ha olvidado añadir la directiva use App\Models\NombreModelo; en la parte superior del archivo de vuestro controlador. ¡Es un error común, pero fácil de solucionar!

Una vez que vuestros controladores estén enviando los objetos de los modelos a las vistas, el último paso es actualizar las vistas Blade para que muestren la información correctamente. Antes, podríais haber estado accediendo a los datos como $array[$key]['campo']. Ahora, como estáis trabajando con objetos de Eloquent, el acceso será mucho más intuitivo: $recurso->campo. Por ejemplo, si pasáis un objeto familia a la vista, podréis mostrar su nombre con {{ $familia->nombre }}. ¡Es más limpio y más legible!

Además, un detalle crucial para la interactividad de vuestro ePortfolio son los enlaces. En la vista .../index.blade.php, cuando creéis enlaces a las páginas de detalle (.../show/{id}), ya no usaréis el índice del array ($key). En su lugar, usaréis el campo id de vuestro objeto modelo: {{ $recurso->id }}. Por ejemplo, route('familias.show', $familia->id). Esto asegura que los enlaces sean persistentes y correctos, apuntando directamente al registro en la base de datos. Lo mismo ocurre en la vista .../show.blade.php; si queréis crear un enlace para editar el recurso, deberéis pasar el id del objeto a la ruta de edición (.../edit/{id}). Esta integración perfecta entre controladores y vistas utilizando Eloquent transforma vuestro ePortfolio en una aplicación dinámica y profesional. ¡Ahora sí que tenéis una aplicación web completa y conectada a su base de datos!

Conclusión: ¡Tu ePortfolio al Máximo Nivel con Bases de Datos en Laravel!

¡Enhorabuena, cracks! Acabamos de dar un salto cualitativo gigantesco en el desarrollo de vuestro ePortfolio. Desde la configuración meticulosa de la base de datos y la creación de esquemas robustos con migraciones, pasando por la definición de modelos que actúan como vuestros mejores aliados para interactuar con los datos, y hasta la inyección de vida en vuestras tablas con seeders, habéis dominado los pilares fundamentales de la gestión de bases de datos en Laravel. Hemos culminado integrando todo esto para que vuestros controladores puedan extraer y manipular datos de forma eficiente, y vuestras vistas los muestren de una manera dinámica y profesional. Ya no dependéis de datos estáticos; ahora vuestro ePortfolio es una aplicación viva, capaz de crecer y adaptarse con la información que almacena. Esta habilidad para gestionar datos es la piedra angular de cualquier aplicación web moderna y os abre un mundo de posibilidades para futuras funcionalidades. Seguid practicando y experimentando, porque la base de datos es el motor de vuestro proyecto. ¡Vuestro ePortfolio ya no es solo un portafolio, es una verdadera plataforma web! ¡A seguir rockeando con Laravel y vuestras habilidades de desarrollo!