Ultima Laravel

Explore

Ejemplo tabla alumnos

Ejemplo aula_online

⁠

Tabla cursos

Ahora creamos el Modelo para la tabla Cursos, con artisan escribimos la siguiente línea de código.

php artisan make:model Curso -m

⁠

Esto crea la migración de la tabla cursos y el modelo Curso

⁠

En el modelo Cursos

⁠

Iremos registrando las configuraciones de la tabla Cursos.

protected $table = "cursos";

protected $primaryKey = "id";

protected $fillable = ['nombre', 'nivel', 'horas_academicas', 'profesor_id'];

protected $hidden = [ 'id'];

⁠

Relaciones en las tablas de migraciones

En la tabla Cursos existen dos relaciones que debemos tomar en cuenta considerando nuestro modelo entidad-relación.

Relación uno a muchos

La relación existente entre la tabla profesores y la tabla cursos, es una relación de uno a muchos (o muchos a uno), es decir, un profesor puede dictar muchos cursos o un curso puede ser dictado por un solo profesor.

En la tabla cursos registramos el IDProfesor como llave foránea de la tabla profesores, esto creará una integridad referencial a nivel de la base de datos.

Si no tendríamos la migración haríamos ( en nuestro caso con la instrucción anterior crea el modelo y la migración)

php artisan make:migration create_cursos_table

El código de la migración

⁠

Vamos a modificar la tabla con los campos que queremos

$table->string('nombre', 75);

$table->string('nivel', 35);

$table->string('horas_academicas', 35)->nullable();

$table->unsignedBigInteger('profesor_id');

$table->foreign('profesor_id')->references('id')->on('profesores');

Quedara

⁠

php artisan migrate:fresh

Esto daría error , ya que tenemos que tener la tabla de profesores en las migraciones antes

⁠

Vamos hacer la migración de la tabla de profesores, pero no lo vamos hacer a la vez que el modelo, ya que la tabla seria por convención de laravel profesors y no es lo que queremos

php artisan make:migration create_profesores_table

⁠

su código

⁠

y cambiamos datos

$table->string('nombre_apellido', 75);

$table->string('profesion', 35);

$table->string('grado_academico', 35)->nullable();

$table->string('telefono', 35)->nullable();

⁠

Si hacemos ala migración ahora seguirá dando error

⁠

Tenemos que cambiar el orden de las migraciones de profesores y cursos

⁠

Lo que hacemos cambiando números iniciales por ejemplo

⁠

si ahora volvemos hacer

⁠

lo hace sin errores y tenemos en la BD

⁠

Tenemos

⁠

Creamos el modelo Profesor

php artisan make:model Profesor

⁠

class Profesor extends Model

{

use HasFactory;

protected $table = "profesores";

protected $primaryKey = "id";

protected $fillable = ['nombre_apellido', 'profesion', 'grado_academico', 'telefono'];

protected $hidden = ['id'];

}

En este modelo es necesario protected $table = "profesores"; ya que no sigue la convención de laravel

Tabla Pivot

La relación entre la tabla alumnos y cursos es una relación muchos a muchos (Un alumno puede tomar varios cursos, un curso puede tener muchos alumnos).

De manera similar, En las migraciones se debe indicar esta relación (muchos a muchos), creando una tabla Pivot (tercera tabla), esto lo realizaremos en el mismo método up de la clase curso.

Schema::create('alumno_curso', function(Blueprint $table){

$table->increments('id');

$table->unsignedBigInteger('curso_id');

$table->foreign('curso_id')->references('id')->on('cursos')->onDelete('cascade');

$table->unsignedBigInteger('alumno_id');

$table->foreign('alumno_id')->references('id')->on('alumnos')->onDelete('cascade');

});

⁠

Si queremos volver hacia atrás la última migración realizada

$ php artisan migrate:rollback

y luego hacemos

$ php artisan migrate

Seeders

php artisan make:seeder ProfesorSeeder

⁠

public function run()

{

$profesor = new Profesor();

$profesor->nombre_apellido = 'Jaime Peredo';

$profesor->profesion = 'Ingeniero de Sistemas';

$profesor->grado_academico = 'Licenciatura';

$profesor->save();

$profesor1 = new Profesor();

$profesor1->nombre_apellido = 'Daniel Coria';

$profesor1->profesion = 'Administracion Empresas';

$profesor1->grado_academico = 'Licenciatura';

$profesor1->save();

$profesor2 = new Profesor();

$profesor2->nombre_apellido = 'Pedro Poveda';

$profesor2->profesion = 'Ingeniero de Electronico';

$profesor2->grado_academico = 'Masterado';

$profesor2->save();

}

Cambiamos el Dataseeder

⁠

$this->call(ProfesorSeeder::class);

Seeder cursos

Hacemos lo mismo tabla cursos

php artisan make:seeder CursoSeeder

⁠

Insertar datos en la tabla pivot Laravel

Finalmente la relación de la tablas Alumnos con Cursos que es una relación muchos a muchos, existen funciones que te ofrece Eloquent para llenar la tabla pívot, en nuestro caso la tabla es alumno_curso, el método que utilizaremos es attach().

En la misma clase CursoSeeder creamos la relación que existe entre Alumno y Curso.

$curso->alumnos()->attach(1);

$curso->alumnos()->attach(2);

$curso1->alumnos()->attach(1);

$curso1->alumnos()->attach(3);

$curso2->alumnos()->attach(1);

$curso2->alumnos()->attach(2);

⁠

En la misma variable $curso se puede referenciar a la tabla alumnos, gracias a la relación que se va a realizar en los modelos Alumno y Curso con el método belongsToMany; con el método attach() se envía el Id de un alumno en específico.

Por último realizamos la referencia de la clase Curso.

use App\Models\Curso;

Cambiamos Dataseeder

⁠

$this->call(AlumnoSeeder::class);

$this->call(ProfesorSeeder::class);

$this->call(CursoSeeder::class);

Ejecutar Seeders

Antes hacemos las relaciones para que funcione

Relaciones en Eloquent

En tabla Profesores con la tabla Cursos, existe una relación muchos a uno (Un profesor puede dictar muchos cursos, un curso puede ser dictado por un solo profesor) .

Definir relaciones en los modelos

En el modelo Profesor utilizaremos el método hasMany que define la relación uno a muchos.

public function cursos(){

return $this->hasMany(Curso::class);

}

⁠

Para definir la inversa de una relación utilizaremos en el modelo Curso el método belongsTo que define la relación muchos a uno.

public function profesor(){

return $this->belongsTo(Profesor::class);

}

⁠

De igual forma, veremos la relación de la tabla Alumnos y Cursos; existe una relación muchos a muchos (Un alumno puede tomar varios cursos, un curso puede tener muchos alumnos), la relación muchos a muchos lo plasmamos en nuestro modelo.

En el modelo Alumno utilizaremos el método belongsToMany que define la relación, muchos a muchos.

public function cursos(){

return $this->belongsToMany(Curso::class);

}

⁠

Del mismo modo en el modelo Curso utilizamos el mismo método belongsToMany que define la relación muchos a muchos.

public function alumnos(){

return $this->belongsToMany(Alumno::class);

}

⁠

Ahora se ejecutamos los seeders

php artisan migrate:fresh

⁠

Este código lo primero que hará es eliminar todas las tablas de nuestra base de datos y seguidamente volverá a generar todas las tablas sin datos. Ahora ejecutamos la siguiente línea de código que llenará las tablas con datos.

php artisan db:seed

⁠

Comprobamos en la BD

⁠

Tenemos la estructura de nuestra BD

⁠

Factories

Laravel cuenta con los Factories que es otro forma de llenar los datos de una forma más automatizada, y generar gran cantidad de datos.

Factory Profesor

php artisan make:factory ProfesorFactory

⁠

Este comando creara un clase ProfesorFactory dentro de la carpeta database/factories, si exploramos el archivo vemos que hace referencia al Modelo Profesor.

⁠

llenamos de datos nuestro ProfesorFactory en el método definition() dentro de return definimos todos los campos de nuestra tabla profesores con sus respectivos tipos de valores.

'nombre_apellido' => $this->faker->firstName() . ' ' . $this->faker->lastName(),

'profesion' => $this->faker->randomElement(['Ing. Sistema', 'Ing Electronico', 'Adm Empresas', 'Ing Comercial']),

'grado_academico' => $this->faker->word(),

'telefono' => $this->faker->phoneNumber()

⁠

Ahora para poder utilizar la clase ProfesorFactory, nos vamos a nuestro clase ProfesorSeeder, comentamos el código que anteriormente desarrollamos y escribimos lo siguiente:

⁠

Factory Alumno

Realizaremos los mismos pasos en la clase AlumnoFactory,

php artisan make:factory AlumnoFactory

⁠

'nombre_apellido' => $this->faker->firstName() . ' ' . $this->faker->lastName(),

'edad' => $this->faker->randomElement([18, 19, 20, 21]),

'telefono' => $this->faker->phoneNumber(),

'direccion' => $this->faker->address()

⁠

Alumno::factory(10)->create();

⁠

Factory Curso

Por último vemos la tabla cursos, como en los Seeders hay que prestarle atención a esta clase por las relaciones que tiene la tabla cursos con las tablas profesores y alumnos de la base de datos.

Crearemos la clase CursoFactory.

php artisan make:factory CursoFactory

⁠

Igual que en los anteriores Factories llenamos los campos de la tabla cursos, aquí lo diferente es que se tiene que ver la relación que existe primero entre la tabla cursos con la tabla profesores.

'nombre' => $this->faker->word(),

'nivel' => $this->faker->randomElement(['Basico', 'Intermedio', 'Avanzado']),

'horas_academicas' => $this->faker->randomElement(['10 Horas', '40 Horas', '80 Horas']),

'profesor_id' => Profesor::all()->random()->id

⁠

Al momento de referenciar el campo profesor_id, voy a llamar al Modelo Profesor, recuperar todos los registros y por último aleatoriamente escoger un ID

Ahora iremos a la clase CursoSeeder, comentamos el código anterior, y escribimos la siguiente línea de código.

Curso::factory(10)->has(Alumno::factory()->count(4))->create();

Esta línea de código primeramente creará 10 registros en la tabla cursos, seguidamente creará 40 registro en la tabla alumno, por último creará las relaciones en la tabla alumno_curso por cada curso estarán registrados cuatro alumnos.

⁠