Tema 7.

Trabajar con ORM

Introducción

Para trabajar con bases de datos en Laravel no necesitamos escribir SQL manualmente, ni siquiera usar el generador de consultas. Laravel
nos permite interactuar con la base de datos a un nivel mucho más alto a través del Eloquent ORM. Usar Eloquent nos permite trabajar con
modelos, que son clases que representan tablas en la base de datos y proporcionan métodos que son los que pueden interactuar en una
interfaz más "elocuente" y orientada a objetos.

Eloquent (incluido en Laravel) proporciona una solución sencilla para trabajar con bases de datos. Cada tabla de base de datos tiene un
modelo que se utiliza para interactuar con esa tabla. Los modelos permiten consultar los datos de tus tablas, así como insertar nuevos
registros en la tabla (Laravel, 2022).

Como ejemplo práctico para aprender a trabajar con Eloquent, imaginemos que tenemos una tienda de venta de perfumes, se nos ha
proporcionado un documento de requisitos a partir del cual podemos identificar entidades en el sistema. Es importante saber que, por
convención, los modelos están en singular y con la primera letra en mayúscula, mientras que las migraciones están en plural y todas en
minúsculas, todas en inglés:
  Usuarios (Plantilla: Usuario - Migración: usuarios).
 Órdenes (Plantilla: Orden - Migración: órdenes).
 Facturas (Plantilla: Factura - Migración: facturas).
 Artículos (Plantilla: Artículo - Migración: artículos).
 Categorías (Plantilla: Categoría - Migración: categorías).
 Transacciones (Modelo: Transacción - Migración: transacción).

Es importante pensar en cómo se relacionan entre sí. Aunque puede haber muchas relaciones, para estudiar, en general, utilizaremos las
siguientes:

 Usuarios a pedidos: uno a muchos (un usuario puede tener muchos pedidos).
 Pedidos y facturas: uno a uno (un pedido está vinculado a una factura).
 Órdenes a artículos: muchos a muchos (un pedido puede tener muchos artículos).
 Artículos a categorías: uno a muchos (un artículo puede tener muchas categorías).
 Órdenes a transacciones : de una a muchas (es normal pensar que cuando se realiza una orden hay una transacción de pago, pero si
ocurre un error se debe volver a realizar la transacción; en otro caso el usuario decide pagar un porcentaje usando su/ su tarjeta y
otra en efectivo).

Es posible que existan muchas más relaciones, estas pueden ser prácticas o no, depende enteramente del Product Owner y su necesidad. En
este curso estos se toman como objeto de estudio.

Recuerda que, llegado a este punto, tener un diagrama ER que exprese gráficamente las entidades y las relaciones entre ellas es muy
importante para evitar improvisaciones a la hora de codificar.

Explicación

7.1. Modelado

Considerando la estrategia de modelado, lo siguiente que debemos hacer es tomar esas entidades de base de datos y crearlas en nuestro
Framework. Para hacerlo, considere lo siguiente:
 1. Antes de codificar debemos resolver, plantear gráficamente mediante diagramas el comportamiento de nuestra solución y tener
nuestro Diagrama Entidad Relación (puedes practicarlo y crearlo tú mismo a partir de la información proporcionada).
2. Crea un nuevo proyecto Laravel (el proyecto se llamará "tienda").

Iniciamos nuestro servidor de desarrollo con lo siguiente:

 >php artisan serve

Crear los modelos junto con las migraciones es una buena práctica, ya que ambos tienen una relación muy estrecha; la migración es el
archivo que contendrá los códigos para que Eloquent ejecute los comandos SQL que crearán la base de datos real, y los modelos son los que
se encargarán de gestionar sus transacciones.

Por defecto, Laravel ya viene con el Modelo de Usuario. Hay dos archivos a considerar:

 Migración: base de datos/migrations/XXX_XX_XX_XX_create_users_table.php

 La plantilla: aplicación/Usuario

En el siguiente tema exploraremos en detalle el tema de las migraciones. En este tema crearemos sus archivos, pero también nos centraremos
únicamente en los modelos.

Crearemos la migración y el modelo para Category . Laravel nos permite generar migración y modelo en un solo comando creando el
modelo y pasando el parámetro '-m' como referencia a la creación de la migración:

 >php artisan make:model Category -m

Recuerda que siempre puedes recurrir a la ayuda de Artisan.

Luego de ingresar el comando se creará el Modelo de Categoría y su respectiva migración:

Puede acceder a los archivos en la carpeta de la aplicación para el modelo y en la base de datos/migraciones para la migración.

Modificamos la migración para agregar un String llamado 'nombre':

public function up()

{
Schema::create('categories', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->timestamps();
 });
}

Crearemos los modelos restantes de Orden y Artículo , así como sus migraciones:

 >php artisan make:model Order -m

 >php artisan make:model Item -m

Dado que un pedido puede tener muchos artículos, necesitamos una tabla dinámica que nos ayude con la relación de muchos a muchos. Por
convención, colocamos los modelos en orden alfabético:

 >php artisan make:migration create_item_order_table --create="item_order"

Creamos los demás modelos y migraciones:

 >php artisan make:model Invoice -m

 >php artisan make:model Transaction -m
Luego viene la parte "difícil": la definición de las relaciones del modelo. Para ello necesitamos volver a la lista que describe el tipo de
relaciones, o nuestro diagrama ER.

 Usuarios a pedidos: uno a muchos.

 Pedidos a facturas: uno a uno.
 Órdenes a artículos: muchos a muchos.
 Artículos a categorías: uno a muchos.
 Órdenes a transacciones: uno a muchos.

Siempre es un buen momento para revisar la documentación de Laravel, que nos proporcionará la sintaxis adecuada para cada tipo de
relación. En nuestro caso trabajaremos con relaciones de pareja, es decir; Usuario-Pedido, Pedido-Factura, etcétera.

Empezamos definiendo que un usuario puede tener muchos pedidos:

Relación Usuario-Pedido:

Modelo de usuario, agregamos al final de la clase Usuario:

public function orders() {

return $this->hasMany(Order::class);
}

Modelo de orden , agregamos dentro de la clase Orden:

public function user() {

return $this->belongsTo(User::class);
}

Existe la relación Uno a Muchos (para Usuario) y Uno a Muchos Inversos (para Orden). Debes tener cuidado de especificar a qué modelo
pertenece cada uno de estos. Una buena práctica es utilizar una declaración: "un usuario puede tener muchos (tiene muchos) pedidos y
un pedido pertenece a (pertenece a) un usuario". Si ponemos la relación al revés, un pedido tendría muchos usuarios, y un usuario
pertenecería a un pedido, lo cual no tiene sentido.
Por otro lado, considere que para que esto funcione, en las migraciones debe colocar las columnas apropiadas que harán referencia a las
relaciones, las columnas de tipo foráneo que se encargarán de almacenar los ID a los que nos referimos en la relación, pero hazlo en el
siguiente tema.

Relación Pedido-Factura:

Modelo de pedido:

public function user() {

return $this->belongsTo(User::class);
}

public function invoice() {

return $this->hasOne(Invoice::class);
}

Modelo de factura:

public function order() {

return $this->belongsTo(Order::class);
}

Tenga en cuenta que en la relación Uno a Uno también tiene su forma inversa, es decir, "un pedido tiene una factura, una factura pertenece a
un pedido". La diferencia entre HasOne y BelongsTo define la dirección de la relación.

Relación artículo-pedido:

public function orders() {

return $this->belongsToMany(Order::class);
}
Artículo modelo:

public function user() {

return $this->belongsTo(User::class);
}

public function invoice() {

return $this->hasOne(Invoice::class);
}

public function items() {

return $this->belongsToMany(Item::class);
}

Puede intentar modelar artículos en categorías y pedidos en transacciones por su cuenta. Ayúdate con el lenguaje construyendo una
declaración de cómo se comporta la relación e identifica las palabras clave para saber en qué dirección va.

7.2. Migrar

A diferencia de versiones anteriores, Laravel 7 incluye dos métodos id( ) y foregnId() que tienen como objetivo simplificar la forma en que
el sistema de migración define las columnas de clave primaria y externa de las aplicaciones, pero ¿ qué son las migraciones?

En Laravel, se dice que las migraciones son control de versiones de bases de datos, pero son más que eso. Las migraciones permiten crear
tablas, establecer relaciones, modificarlas y, por supuesto, eliminarlas. Todo esto a través de la consola de Comando.

Comenzando por la migración que corresponda al modelo de Usuario , modificaremos su migración para adaptarla a nuestras necesidades.
Recuerde que la migración se encuentra dentro de la carpeta base de datos/migraciones ). Como ahora no estamos trabajando con un
proyecto, no será necesario ingresar contraseñas ni correo electrónico, nuestra tabla solo tendrá dos columnas: el ID y el nombre de usuario.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateUsersTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
});
}

/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('users');
}
}

Notará que, en el archivo de migración, CreateUsersTable es una clase que extiende Migration y contiene dos funciones de tipo público,
arriba () y abajo (). Estas funciones son las que se ejecutan cuando migramos o revertimos nuestra base de datos. Entonces, al ejecutar la
migración, la Fachada Schema creará la tabla 'usuarios' (automáticamente se crea la migración en minúsculas y plural) con cada uno de los
atributos que le indiquemos.

Existen múltiples tipos de columnas, en la documentación oficial de Laravel (2022) se mencionan las siguientes:
 Dominio Descripción
$table->id(); Alias de $table-> bigIncrements( 'id').
$table->foreignId('user_id'); Alias de $table-> unsignedBigInteger( 'user_id').
Columna equivalente de incremento automático UNSIGNED
$table->bigIncrements('id');
BIGINT (clave principal).
$table->bigInteger('votes'); Columna equivalente BIGINT.
$table->binary('data'); Columna equivalente BLOB.
$table->boolean('confirmed'); Columna equivalente booleana.
$table->char('name', 100); Columna equivalente a CHAR con una longitud.
$table->date('created_at'); Columna equivalente a FECHA.
$table->dateTime('created_at', 0); Columna equivalente a DATETIME con precisión (dígitos totales).
Columna equivalente DATETIME (con zona horaria) con precisión
$table->dateTimeTz('created_at', 0);
(dígitos totales).
Columna equivalente DECIMAL con precisión (dígitos totales) y
$table->decimal('amount', 8, 2);
escala (dígitos decimales).
DOBLE columna equivalente con precisión (dígitos totales) y escala
$table->double('amount', 8, 2);
(dígitos decimales).
$table->enum('level', ['easy', 'hard']); Columna equivalente ENUM.
Columna equivalente a FLOAT con precisión (dígitos totales) y
$table->float('amount', 8, 2);
escala (dígitos decimales).
$table->geometry('positions'); Columna equivalente GEOMETRÍA.
$table->geometryCollection('positions'); Columna equivalente GEOMETRYCOLLECTION.
Columna equivalente de INTEGER SIN FIRMAR (clave principal)
$table->increments('id');
de incremento automático.
$table->integer('votes'); Columna equivalente INTEGER.
$table->ipAddress('visitor'); Columna equivalente de dirección IP.
$table->json('options'); Columna equivalente JSON.
$table->jsonb('options'); Columna equivalente JSONB.
$table->lineString('positions'); Columna equivalente a LINESTRING.
$table->longText('description'); Columna equivalente LONGTEXT.
$table->macAddress('device'); Columna equivalente de dirección MAC.
 Columna equivalente de incremento automático UNSIGNED
$table->mediumIncrements('id');
MEDIUMINT (clave principal).
$table->mediumInteger('votes'); Columna equivalente MEDIUMINT.
$table->mediumText('description'); Columna equivalente MEDIUMTEXT.
Agrega columnas equivalentes taggable_id UNSIGNED BIGINT y
$table->morphs('taggable');
taggable_type VARCHAR.
Agrega columnas equivalentes UUID taggable_id CHAR( 36) y
$table->uuidMorphs('taggable');
taggable_type VARCHAR(255).
$table->multiLineString('positions'); Columna equivalente MULTILINESTRING.
$table->multiPoint('positions'); Columna equivalente MULTIPUNTO.
$table->multiPolygon('positions'); Columna equivalente MULTIPOLYGON.
Agrega versiones que aceptan valores NULL de columnas morphs(
$table->nullableMorphs('taggable');
).
Agrega versiones que admiten valores NULL de columnas
$table->nullableUuidMorphs('taggable');
uuidMorphs( ).
$table->nullableTimestamps(0); Alias del método de marcas de tiempo ( ).
$table->point('position'); Columna equivalente de PUNTO.
$table->polygon('positions'); Columna equivalente POLYGON.
Agrega una columna equivalente a Remember_token VARCHAR(
$table->rememberToken();
100) que acepta valores NULL.
$table->set('flavors', ['strawberry', 'vanilla']); SET columna equivalente.
Columna equivalente UNSIGNED SMALLINT (clave principal) de
$table->smallIncrements('id');
incremento automático.
$table->smallInteger('votes'); Columna equivalente SMALLINT.
Agrega una columna equivalente a TIMESTAMP que acepta valores
$table->softDeletes('deleted_at', 0);
NULL para eliminaciones temporales con precisión (dígitos totales).
Agrega una columna equivalente a TIMESTAMP (con zona horaria)
$table->softDeletesTz('deleted_at', 0); que acepta valores NULL para eliminaciones temporales con
precisión (dígitos totales).
$table->string('name', 100); Columna equivalente VARCHAR con una longitud.
$table->text('description'); Columna equivalente de TEXTO.
$table->time('sunrise', 0); Columna equivalente de TIEMPO con precisión (dígitos totales).
Columna equivalente a HORA (con zona horaria) con precisión
$table->timeTz('sunrise', 0);
(dígitos totales).
Columna equivalente a TIMESTAMP con precisión (dígitos
$table->timestamp('added_on', 0);
totales).
Columna equivalente a TIMESTAMP (con zona horaria) con
$table->timestampTz('added_on', 0);
precisión (dígitos totales).
Agrega columnas equivalentes a TIMESTAMP que aceptan valores
$table->timestamps(0);
NULL con precisión (dígitos totales).
Agrega columnas equivalentes a TIMESTAMP (con zona horaria)
$table->timestampsTz(0);
que aceptan valores NULL con precisión (dígitos totales).
Columna equivalente de TINYINT (clave principal) de incremento
$table->tinyIncrements('id');
automático.
$table->tinyInteger('votes'); Columna equivalente a TINYINT.
$table->unsignedBigInteger('votes'); Columna equivalente UNSIGNED BIGINT.
Columna equivalente a DECIMAL SIN FIRMAR con precisión
$table->unsignedDecimal('amount', 8, 2);
(dígitos totales) y escala (dígitos decimales).
$table->unsignedInteger('votes'); Columna equivalente de INTEGER UNSIGNED.
$table->unsignedMediumInteger('votes'); Columna equivalente UNSIGNED MEDIUMINT.
$table->unsignedSmallInteger('votes'); Columna equivalente UNSIGNED SMALLINT.
$table->unsignedTinyInteger('votes'); Columna equivalente a TINYINT SIN FIRMAR.
$table->uuid('id'); Columna equivalente UUID.
$table->year('birth_year'); Columna equivalente al AÑO.
Tipos de columnas disponibles
Fuente : Laravel. (2022). Base de datos: Migraciones . Obtenido de https://laravel.com/docs/7.x/migrations

Categorías migratorias:

public function up()

{
Schema::create('categories', function (Blueprint $table) {
$table->id();
 $table->string('name');
$table->timestamps();
});
}

Órdenes de migración:

public function up()

{
Schema::create('orders', function (Blueprint $table) {
$table->id();
$table->string('status');
$table->unsignedInteger('total_value');
$table->unsignedInteger('taxes');
$table->unsignedInteger('shipping_charges');

$table->unsignedBigInteger('user_id');
$table->foreign('user_id')
->references('id')
->on('users')
->onDelete('cascade');
});
}

Migración de artículos:

public function up()

{
Schema::create('items', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->text('description');
$table->string('type');
$table->unsignedInteger('price');
$table->unsignedInteger('quantity_in_stock');
 $table->unsignedBigInteger('order_id');
$table->foreign('order_id')
->references('id')
->on('orders')
->onDelete('cascade');
});
}

Tabla dinámica de migración item_order:

public function up()

{
Schema::create('item_order', function (Blueprint $table) {
$table->unsignedBigInteger('order_id');
$table->foreign('order_id')
->references('id') ->on('orders')
->onDelete('cascade');

$table->unsignedBigInteger('item_id');
$table->foreign('item_id')
->references('id')
->on('items')
->onDelete('cascade');
});
}

Facturas de migración:

public function up()

{
Schema::create('invoices', function (Blueprint $table) {
$table->id();
 $table->timestamp('raised_at')->nullable();
$table->string('status');
$table->unsignedInteger('totalAmount');

$table->unsignedBigInteger('order_id')->unique();
$table->foreign('order_id')
->references('id')
->on('orders')
->onDelete('cascade')
->unique();
});
}

Transacciones migratorias:

public function up()

{
Schema::create('transactions', function (Blueprint $table) {
$table->id();
$table->timestamp('executed_at');
$table->string('status');
$table->string('payment_mode');
$table->string('transaction_reference')->nullable();

$table->unsignedBigInteger('order_id');
$table->foreign('order_id')
->references('id')
->on('orders')
->onDelete('cascade');
});
}
Finalmente llega el momento de ejecutar las migraciones, esto se hace con el comando Artisan:

 php artisan migrate

Es muy importante que la creación de las migraciones tenga un orden específico, porque cuando se ejecuten las migraciones, se harán de
forma ordenada. Cuando hacemos una referencia en la migración a través de un Foreign a una tabla que no ha sido creada, la migración
devolverá un error, lo cual se soluciona cambiando el nombre de la migración de tal manera que quede antes de la migración en la que se
está referenciado.

Tenga en cuenta que los archivos de migración se crean con el siguiente formato:

 año_mes_día_num_create_migrationname_table.

Puedes acudir a tu gestor de bases de datos favorito y comprobar que efectivamente la base de datos, sus tablas y relaciones son correctas.
7.3. Sembradoras y fábricas

Cuando estamos en la etapa de desarrollo es muy útil tener datos de prueba, esto para probar ciertas partes de nuestra aplicación, por
ejemplo:

 Consultas a nuestra base de datos con Eloquent.

 Mostrar datos que nos permitan verificar la funcionalidad de nuestra aplicación.

Remitentes.

Laravel incluye un método simple para "sembrar" su base de datos de prueba usando una clase llamada Seeder . Todas las clases de semillas
se almacenan en el directorio base de datos/seeds . Los Seeders pueden tener cualquier nombre, pero se recomienda tener una convención
sensata, como UserSeeder, ProductSeeder, entre otras. De forma predeterminada, se define y utiliza una clase DatabaseSeeder para ejecutar
otros sembradores (Laravel, 2022).

Si observa el archivo base de datos/sedes/DatabaseSeeder.php , verá la siguiente estructura:

<?php

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder

{
/**
* Seed the application's database.
*
* @return void
*/
public function run()
{
// $this->call(UserSeeder::class);
}
}
Por defecto, hay una línea comentada dentro de la función ejecutar ( ) para ejecutar un sembrador llamado UserSeeder (que no es el
predeterminado, hay que crearlo). Esto se hace de la siguiente manera:

 >php artisan make:seeder UserSeeder

Y el contenido de UserSeeder es el siguiente:

<?php

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder

{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
//
}
}

Considerando que en la tabla de usuarios solo tenemos la tabla id que es la clave primaria y autoincremental, nos interesa la tabla de tipo
String 'nombre':

<?php
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB; // Important import
class UserSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('users')->insert([
'name' => 'Tecmilenio'
]);
}
}

También debemos enfatizar que, normalmente, si trabajamos con la tabla de usuarios en un desarrollo formal, además del 'nombre', también
se requiere llenar las tablas 'correo electrónico' y 'contraseña'. Para ello utilizaríamos lo siguiente:

DB::table('users')->insert([
'name' => Str::random(10), // it will create a random word with 10 digits
'email' => Str::random(10).'@gmail.com', // random email with 10 digits
'password' => Hash::make('password'), // coded ‘password’ word
]);

No olvides que para trabajar con la generación de Strings, y las DB y Hash Facades se deben importar, estos ayudarán con la generación de
los datos:

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;
Una vez que tengamos seeders para nuestros usuarios, debemos ejecutar nuestras migraciones nuevamente. Como ya los tenemos creados los
actualizaremos, pero debemos especificar que queremos ejecutar los seeders; es recomendable hacer uso de la ayuda de Artisan, y en el
archivo DatabaseSeeder descomentar la línea que hace referencia al sembrador UserSeeder :

<?php

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder

{
/**
* Seed the application's database.
*
* @return void
*/
public function run()
{
$this->call(UserSeeder::class);
}
}
El comando a ejecutar es el siguiente:

 >php artisan migrate:fresh -seed

Puede notar que, al especificar que queremos una actualización en las migraciones y agregar el parámetro --seed, ejecutó la función down ()
de nuestras migraciones y luego ejecutó la función up () para crear nuevamente nuestra tabla, y al final ejecutó la migración, llenando con
información la tabla que especificamos.
Podemos crear tantas semillas como queramos, siempre respetando la estructura de las tablas de la base de datos, y creando un seeder para
cada una de nuestras tablas.

Fábricas

Llenar un par de datos por cada vez que debemos actualizar nuestra base de datos por cualquier motivo es de gran ayuda, pero en desarrollo
es común que se requieran más datos para realizar pruebas y llenar uno por uno es un trabajo que puede llevar mucho tiempo, dependiendo
de ¿Cuántos datos se requieren?

Habrá ocasiones en las que nuestras pruebas requieran rendimiento, y deberemos crear 20.000 o 30.000 (o más) registros para medir el
rendimiento de nuestras consultas y cargas, para ello Laravel proporciona una variedad de herramientas útiles para facilitar las pruebas de
aplicaciones que utilizan Las bases de datos y las sembradoras son insuficientes, ni nos representan para invertir un tiempo valioso en crear
sembradora por sembradora.

Las fábricas son sencillas de utilizar, sólo debes especificar en cada campo de la tabla qué tipo de datos quieres llenar y, posteriormente, el
número de registros que quieres generar en la tabla.

Echemos un vistazo a Factory UserFactory.php ubicado en la carpeta base de datos/fábricas :

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\User;
use Faker\Generator as Faker;
use Illuminate\Support\Str;

/*
|--------------------------------------------------------------------------
| Model Factories
|--------------------------------------------------------------------------
|
| This directory should contain each of the model factory definitions for
| your application. Factories provide a convenient way to generate new
| model instances for testing / seeding your application's database.
|
*/

$factory->define(User::class, function (Faker $faker) {

return [
'name' => $faker->name,
'email' => $faker->unique()->safeEmail,
'email_verified_at' => now(),
'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
'remember_token' => Str::random(10),
];
});

Para que el Factory funcione se utiliza una biblioteca PHP llamada Faker , su documentación se puede encontrar en el siguiente enlace y su
uso es muy sencillo (FakerPHP, sf). En este ejemplo no trabajaremos con la Fábrica de usuarios, pero crearemos una Fábrica para nuestra
tabla de categorías :

 >php artisan make:factory CategoryFactory --model=Category

En su fábrica añadiremos lo siguiente:

<?php
/** @var \Illuminate\Database\Eloquent\Factory $factory */
use App\Category;
use Faker\Generator as Faker;
$factory->define(Category::class, function (Faker $faker) {
return [
'name' => $faker->word
];
});

Es importante identificar el tipo de datos que utilizaremos para que nuestra fábrica haga su trabajo, eso depende del tipo de datos. En la
documentación de Faker podemos encontrar datos relacionados con texto y párrafos (FakerPHP, sf).

Finalmente en el archivo DatabseSeeder registramos nuestra fábrica con dos parámetros, el modelo que utilizará y el número de registros:

<?php
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{

/**
* Seed the application's database.
*
* @return void
*/

public function run()

{
$this->call(UserSeeder::class);
 factory(App\Category::class, 20)->create();
}
}

Realizamos las migraciones:

 >php artisan migrate:refresh -seed

Al final de las migraciones, parecerá que todo fue exitoso.

Luego podemos verificar en la base de datos que efectivamente ha llenado la tabla de categorías con 20 registros:
Conclusión

El proceso de modelado, migraciones y llenado de datos en la base de datos puede ser un tema algo complicado cuando no se siguen las
mejores prácticas. En este tema observaste cómo con una planificación adecuada, Eloquent ORM nos brinda herramientas poderosas para
trabajar con bases de datos.

Durante el desarrollo de tus proyectos, es muy probable que tengas que crear y eliminar tu base de datos, las migraciones son la herramienta
ideal para que este proceso no sea un dolor de cabeza, y las sembradoras y fábricas son el complemento ideal para tener siempre tu
información tiempo, así como un volumen respetable de información para sus pruebas.

Control

Asegúrate de que:

 Revisar constantemente la documentación del framework.

 Utilice siempre la consola Artisan y Eloquent.
 Comprender el uso de sembradoras y fábricas.

Referencias

 FakerPHP. (Dakota del Norte). Farsante . Obtenido de https://fakerphp.github.io

 Laravel. (2022). Documentación Oficial V.7.x. Obtenido de https://laravel.com/docs/7.x

Recursos adicionales
 Los siguientes enlaces no pertenecen a la Universidad Tecmilenio, al acceder a ellos deberá aceptar sus términos y condiciones.

Vídeos

 Para obtener información sobre la migración , mire el siguiente vídeo:

Code With Dary. (2020, 23 de diciembre). Bases de Datos y Migraciones | Laravel para principiantes | Aprenda Laravel [archivo
de vídeo]. Obtenido de https://www.youtube.com/watch?v=g-63ClKANsM

 Para obtener más información sobre las fábricas , mire el siguiente vídeo:
Code With Dary. (2020, 25 de diciembre). Fábricas de modelos | Laravel para principiantes | Aprenda Laravel [archivo de
vídeo]. Obtenido de https://www.youtube.com/watch?v=Lsc2gIPSMyI

 Para obtener más información sobre Eloquent , mire el siguiente vídeo:

Code With Dary (30 de diciembre de 2020). Introducción a elocuente | Laravel para principiantes | Aprenda Laravel [archivo de
vídeo]. Obtenido de https://www.youtube.com/watch?v=ufCAN-bAFn0

Lecturas

 Para conocer más sobre la consola Artisan , te recomendamos leer:

Laravel. (2022). Consola Artesanal. Obtenido de https://laravel.com/docs/9.x/artisan
  Para conocer más sobre la consola Eloquent , recomendamos leer:
Laravel. (2022). Elocuente: introducción . Obtenido de https://laravel.com/docs/9.x/eloquent

 Para conocer más sobre Seeding , te recomendamos leer:

Laravel. (2022). Base de datos: Siembra . Obtenido de https://laravel.com/docs/9.x/seeding

Actividad 7

Descripción

El estudiante creará un diagrama ER para expresar entidades y relaciones, para luego modelarlas utilizando Eloquent ORM.

Objetivo

Modelar una base de datos relacional utilizando Eloquent.

Requisitos

Computadora con acceso a Internet, tenga instalado XAMPP, o WAMP, MAMP, LAMP o Laragon Stack.

Instrucciones

Primero lea el siguiente caso:

Una pequeña escuela de robótica te solicitó un pequeño sistema que será de ayuda para sus profesores para impartir clases; todos los usuarios
podrán tener un usuario en la plataforma, y los roles son estudiantes, docentes y administrativos. Los cursos son muy importantes en la
plataforma, cada curso debe tener un título, una portada y el contenido. Además, cada curso cuenta con un material didáctico. El cliente
compartió algunos registros de su Excel con cursos:
 Clave del curso Nombre del curso kit de robótica
Rob101 Introducción a la robótica Kit de inicio
Rob102 Introducción a la automatización Kit de inicio
Rob103 Programación para Robótica Kit de Robótica Educativa
Rob104 Características de un robot Kit5
El objetivo de la plataforma es crear grupos con estudiantes y asignarles cursos que puedan consultar directamente en la plataforma que
debes programar. Los grupos serán "principiante", "intermedio" y "avanzado", pero es posible que en el futuro se abran más grupos.
Recuerde lo siguiente:

 Un usuario puede ser un estudiante, un profesor o un administrador.

 Un estudiante pertenece a un grupo.
 Un grupo puede tener varios cursos.
 Un curso cuenta con un kit de robótica.

Durante esta actividad, realice lo siguiente:

a. Cree el diagrama ER en el que presente las entidades y sus relaciones (al menos cuatro entidades).
b. Crea un nuevo proyecto de Laravel 7 llamado "actividad7".
c. Crea el proyecto git y el repositorio en GitHub.
d. Usando la consola Artisan, cree lo siguiente:
o Modelos
o Controladores
o Migraciones
e. Cree los atributos, claves primarias y claves externas en los archivos de migración.
f.Crea tus relaciones en sus respectivos modelos.
g. Ejecute sus migraciones.
h. Acceda a su administrador de base de datos y exporte la base de datos en formato .sql.

Recuerde exportar su diagrama ER en uno de los siguientes formatos de imagen: png, jpg o pdf. Incluya el archivo y la URL de su
repositorio de GitHub en el documento del informe .

Entregables
Un documento de informe que incluye el archivo png, jpeg o pdf con diagrama ER, enlace al repositorio del proyecto y archivo de base de
datos en formato SQL.

Criterios de evaluación

 Diagrama ER que muestra las entidades y relaciones (al menos cuatro entidades).
 Proyecto GitHub que contiene lo siguiente:
o Modelos expresados en el diagrama ER.
o Controladores asociados a los modelos expresados en el diagrama ER.
o Migraciones asociadas a los modelos expresados en el diagrama ER.
 Archivo en formato SQL.

Tarea 7

Instrucciones

1. Después de completar la actividad 7, completaremos la base de datos y trabajaremos con la documentación del proyecto:
o Cree un seeder para usuarios y registre tres usuarios:
a. Nombre de usuario: Admon.
Correo electrónico : [email protected]
Contraseña: Adm@2022 Rol: Administrativo.
b. Nombre de usuario: Tecmilenio.
Correo electrónico: [email protected]
Contraseña: Adm@2022 Rol: Docente.
c. Nombre de usuario: Estudiante.
Correo electrónico: [email protected]
Contraseña: Adm@2022 Rol: Estudiante.
2. A continuación, cree una sembradora para los kits de robótica y registre los tres kits que el cliente proporcionó como información
de prueba.
3. Luego, crea una fábrica de cursos, y registra 100 cursos, recuerda consultar la documentación de FakerPHP para que los registros
falsos tengan un tipo de datos acorde a lo que almacenará la base de datos en producción.
 4. Además, modifique el archivo README.md para agregar la siguiente información:
a. Nombre del proyecto
b. Descripción del Proyecto
c. Diagrama ER
5. Finalmente, realice un impulso en su proyecto de GitHub con una confirmación descriptiva sobre las actualizaciones que ha
experimentado el proyecto.

Entregables

Envía tus resultados en el espacio correspondiente de la plataforma.