Ultima Laravel
Share
Explore
Ejemplo tabla alumnos

Ejemplo aula_online

image.png
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
image.png
Esto crea la migración de la tabla cursos y el modelo Curso
image.png
En el modelo Cursos
image.png
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'];
image.png
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
image.png
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
image.png
php artisan migrate:fresh
Esto daría error , ya que tenemos que tener la tabla de profesores en las migraciones antes
image.png
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
image.png
image.png
su código
image.png
y cambiamos datos
$table->string('nombre_apellido', 75);
$table->string('profesion', 35);
$table->string('grado_academico', 35)->nullable();
$table->string('telefono', 35)->nullable();
image.png
Si hacemos ala migración ahora seguirá dando error
image.png
Tenemos que cambiar el orden de las migraciones de profesores y cursos
image.png
Lo que hacemos cambiando números iniciales por ejemplo
image.png
si ahora volvemos hacer
image.png
lo hace sin errores y tenemos en la BD
image.png
Tenemos
image.png
Creamos el modelo Profesor
php artisan make:model Profesor
image.png
image.png
image.png
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');
});
image.png
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
image.png
image.png
image.png
image.png

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
image.png
$this->call(ProfesorSeeder::class);
Seeder cursos
Hacemos lo mismo tabla cursos
php artisan make:seeder CursoSeeder
image.png
image.png

image.png
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);
image.png
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
image.png
$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);
}

image.png
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);
}
image.png
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);
}
image.png
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);
}
image.png

Ahora se ejecutamos los seeders
php artisan migrate:fresh
image.png
image.png
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
image.png
Comprobamos en la BD
image.png
image.png
image.png
image.png
Tenemos la estructura de nuestra BD
image.png
image.png
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
image.png
Este comando creara un clase ProfesorFactory dentro de la carpeta database/factories, si exploramos el archivo vemos que hace referencia al Modelo Profesor.
image.png
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()
image.png
Ahora para poder utilizar la clase ProfesorFactory, nos vamos a nuestro clase ProfesorSeeder, comentamos el código que anteriormente desarrollamos y escribimos lo siguiente:
image.png
Factory Alumno
Realizaremos los mismos pasos en la clase AlumnoFactory,
php artisan make:factory AlumnoFactory
image.png
image.png
'nombre_apellido' => $this->faker->firstName() . ' ' . $this->faker->lastName(),
'edad' => $this->faker->randomElement([18, 19, 20, 21]),
'telefono' => $this->faker->phoneNumber(),
'direccion' => $this->faker->address()
image.png
Alumno::factory(10)->create();
image.png

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
image.png
image.png
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
image.png
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.
image.png
DataSeeder
image.png
Ejecutar los Factories
Por último ejecutamos desde Artisan las migraciones y los seeders, con el fin de llenar de datos nuestra base de datos con los cambios realizados.
php artisan migrate:fresh
image.png
Ejecutamos los seeders.
php artisan db:seed
image.png



Share
 
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.