Header Ads Widget

Ticker

6/recent/ticker-posts

Tutorial CRUD de la API REST de Laravel 7/6 - Construya un CRM [PARTE 2]: Modelos y relaciones elocuentes

 Laravel 7 se lanzó recientemente con muchas mejoras, por lo que aprenderemos, a lo largo de esta serie de tutoriales, cómo crear una aplicación REST API CRUD de ejemplo desde cero. La aplicación que crearemos es un CRM simple con una base de datos MySQL que expone un conjunto de puntos finales de la API REST.

Puede ver esta Guía de actualización para obtener instrucciones sobre cómo actualizar una aplicación web existente de Laravel 6 a Laravel 7.

API REST de Laravel 7

Según Wikipedia :

Representational State Transfer (REST) ​​es un estilo de arquitectura de software que define un conjunto de restricciones que se utilizarán para crear servicios web. Los servicios web que se ajustan al estilo arquitectónico REST, denominados servicios web RESTful (RWS), brindan interoperabilidad entre sistemas informáticos en Internet.

REST significa Transferencia de Estado REpresentacional . Es un estilo arquitectónico para sistemas distribuidos inventado por Roy Fielding en 2000 .

Puede hacer referencia a una API (Interfaz de programación de aplicaciones) o simplemente hacer una interfaz como RESTful si cumple con estas seis restricciones REST :

  • Arquitectura cliente-servidor: su interfaz API REST debe seguir una arquitectura cliente-servidor,
  • Sin estado: su interfaz API REST debe ser sin estado,
  • Se puede almacenar en caché: su interfaz API REST debe poder almacenarse en caché,
  • Interfaz uniforme: su API REST debe tener una interfaz uniforme,
  • Sistema en capas,
  • Código bajo demanda.

¿Qué es un recurso de API REST?

En las API REST, un recurso se refiere a un objeto que tiene un tipo y datos. También tiene un grupo de métodos asociados que pueden operar sobre él. Estos son métodos estándar que corresponden a los métodos HTTP GET, POST, PUT y DELETE estándar.

¿Qué es un método de API REST?

Una API REST es una interfaz que le permite conectar su aplicación web con otros sistemas como dispositivos móviles y navegadores web a través de un conjunto de métodos que corresponden a las operaciones CRUD (crear, leer, actualizar, eliminar). En las reglas REST, debe asignar un método HTTP específico a una operación CRUD específica.

Estos son ejemplos de métodos HTTP asignados a las acciones CRUD que puede realizar su API REST.

  • HTTP GET: este método de API REST se puede asignar a una acción para obtener / recuperar los datos del recurso,
  • HTTP POST: este método de API REST se puede asignar a una acción para crear nuevos recursos,
  • HTTP PUT: este método de API REST se puede asignar a una acción para actualizar los recursos existentes,
  • HTTP DELETE: este método de la API REST se puede asignar a una acción para eliminar el recurso,
  • PARCHE HTTP: Este método de API REST se puede asignar a una acción para realizar una actualización parcial en un recurso.

Creando modelos Laravel 7 de nuestra API REST

De acuerdo con la estructura de la base de datos anterior, necesitaremos crear los siguientes modelos de Eloquent:

  • Contacto
  • Cuenta
  • Actividad
  • ContactStatus
  • Fuente de contacto
  • ActivityStatus

Regrese a su terminal y ejecute los siguientes comandos:

$ php artisan make:model Contact --migration
$ php artisan make:model Account --migration
$ php artisan make:model Activity --migration
$ php artisan make:model ContactStatus --migration
$ php artisan make:model ContactSource --migration
$ php artisan make:model ActivityStatus --migration

Esto creará modelos con los archivos de migraciones correspondientes. Los modelos existen en la appcarpeta y puede encontrar los archivos de migración en la database/migrationscarpeta.

La -mbandera también creará el archivo de migración correspondiente para el modelo.

A continuación, en su terminal, ejecute el siguiente comando para crear las tablas base:

$ php artisan migrate

Obtendrá el siguiente resultado:

Migration table created successfully.
Migrating: 2020_03_04_223818_create_contacts_table
Migrated:  2020_03_04_223818_create_contacts_table
Migrating: 2020_03_04_223832_create_accounts_table
Migrated:  2020_03_04_223832_create_accounts_table
Migrating: 2020_03_04_223841_create_activities_table
Migrated:  2020_03_04_223841_create_activities_table
Migrating: 2020_03_04_223855_create_contact_statuses_table
Migrated:  2020_03_04_223855_create_contact_statuses_table
Migrating: 2020_03_04_223904_create_contact_sources_table
Migrated:  2020_03_04_223904_create_contact_sources_table
Migrating: 2020_03_04_223912_create_activity_statuses_table
Migrated:  2020_03_04_223912_create_activity_statuses_table

En Laravel, puede especificar la estructura (campos de la tabla) en los archivos de migración. Empecemos por la contactsmesa. Abra el database/migrations/2019_09_02_223818_create_contacts_table.phparchivo (el prefijo de fecha para el archivo será diferente para usted) y agregue los siguientes cambios:

    public function up()
    {
        Schema::create('contacts', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->timestamps();
            $table->string('title');
            $table->string('first_name');
            $table->string('last_name');
            $table->string('email');
            $table->string('phone');
            $table->string('address');
            $table->date('date');

            $table->biginteger('user_id')->unsigned(); 
            $table->foreign('user_id')->references('id')->on('users');                                        
        });
    }

A continuación, abra el database/migrations/<YOUR_TIMESTAMP>_create_accounts_table.phparchivo y cámbielo en consecuencia:

    public function up()
    {
        Schema::create('accounts', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->timestamps();
            $table->string('name');
            $table->description('description');           

        });
    }

A continuación, abra el database/migrations/<YOUR_TIMESTAMP>_create_activities_table.phparchivo y cámbielo en consecuencia:

    public function up()
    {
        Schema::create('activities', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->timestamps();
            $table->string('description');

        });
    }

A continuación, abra el database/migrations/<YOUR_TIMESTAMP>_create_contact_statuses_table.phparchivo y cámbielo en consecuencia:

    public function up()
    {
        Schema::create('contact_statuses', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->timestamps();
            $table->string('status');
        });
    }

A continuación, abra el database/migrations/<YOUR_TIMESTAMP>_create_contact_sources_table.phparchivo y cámbielo en consecuencia:

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

A continuación, abra el database/migrations/<YOUR_TIMESTAMP>_create_activity_statuses_table.phparchivo y cámbielo en consecuencia:

    public function up()
    {
        Schema::create('activity_statuses', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->timestamps();
            $table->string('status');            
        });
    }

Puede ver que no creamos ninguna clave externa entre las tablas. Esto se debe a que debemos evitar cualquier problema al crear una clave externa para una tabla que aún no existe. El orden de las migraciones es importante, por lo que debe asegurarse de que las tablas a las que se hace referencia se creen primero o crear las tablas sin claves externas y luego agregar una migración para actualizar las tablas con las relaciones requeridas después de que se creen las tablas.

Ahora, creemos la update_contacts_tablemigración ejecutando el siguiente comando:

$ php artisan make:migration update_contacts_table --table=contacts
Created Migration: 2019_09_02_235456_update_contacts_table

Abra el database/migrations/<YOUR_TIMESTAMP>_update_contacts_table.phparchivo y actualice en consecuencia:

    public function up()
    {
        Schema::table('contacts', function (Blueprint $table) {

            $table->biginteger('source_id')->unsigned();  
            $table->foreign('source_id')->references('id')->on('contact_sources');   

            $table->biginteger('account_id')->unsigned(); 
            $table->foreign('account_id')->references('id')->on('accounts');   

            $table->biginteger('status_id')->unsigned(); 
            $table->foreign('status_id')->references('id')->on('contact_statuses');

        });
    }

Creamos tres relaciones de clave externa para las tablas contact_sourcesaccountscontact_statuses.

A continuación, creemos la update_activities_tablemigración ejecutando el siguiente comando:

$ php artisan make:migration update_activities_table --table=activities
Created Migration: 2019_09_02_002644_update_activities_table

Abra el database/migrations/<YOUR_TIMESTAMP>_update_activities_table.phparchivo y actualice en consecuencia:

    public function up()
    {
        Schema::table('activities', function (Blueprint $table) {
            $table->biginteger('contact_id')->unsigned();  
            $table->foreign('contact_id')->references('id')->on('contacts');   

            $table->biginteger('status_id')->unsigned(); 
            $table->foreign('status_id')->references('id')->on('activity_statuses');   

        });
    }

Creamos dos claves foráneas para la tabla contactsactivity_statuses.

Ahora, ejecute el siguiente comando para migrar su base de datos:

$ php artisan migrate

Implementación de los modelos de API REST de Laravel 7

El ORM Eloquent incluido con Laravel proporciona una implementación de ActiveRecord hermosa y simple para trabajar con su base de datos. Cada tabla de la base de datos tiene un "Modelo" correspondiente que se utiliza para interactuar con esa tabla. Los modelos le permiten consultar datos en sus tablas, así como insertar nuevos registros en la tabla. Los documentos oficiales

Podemos interactuar con las tablas de nuestra base de datos usando los modelos Eloquent correspondientes, por lo que necesitamos implementar los métodos requeridos en cada modelo.

Definiendo las relaciones entre los modelos de Laravel 7

  • Un contacto pertenece a una fuente, un estado, una cuenta y un usuario y tiene muchas actividades.
  • Una cuenta pertenece a un usuario (es decir, creada por un usuario) y tiene muchos contactos.
  • Una actividad pertenece a un estado, un contacto y un usuario.
  • El estado de un contacto tiene muchos contactos.
  • Una fuente de contacto tiene muchos contactos.
  • Un estado de actividad tiene muchas actividades

Abra el app/Account.phparchivo y cámbielo en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Account extends Model
{
    public function contacts(){
        return $this->hasMany('App\Contact');
    }
    public function user(){
        return $this->belongsTo('App\User');
    }
}

A continuación, abra el app/Activity.phparchivo y cámbielo en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Activity extends Model
{
    public function contact(){
        return $this->belongsTo('App\Contact');
    }

    public function status(){
        return $this->belongsTo('App\ActivityStatus');
    }
    public function user(){
        return $this->belongsTo('App\User');
    }
}

A continuación, abra el app/ActivityStatus.phparchivo y cámbielo en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class ActivityStatus extends Model
{
    public function activities(){
        return $this->hasMany('App\Activiy');
    }
}

A continuación, abra el app/Contact.phparchivo y actualice en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Contact extends Model
{
    protected $fillable = [
        'title',
        'first_name',
        'last_name',
        'email',
        'phone',
        'address',
        'date'       
    ];

    public function source(){
        return $this->belongsTo('App\ContactSource');
    }

    public function status(){
        return $this->belongsTo('App\ContactStatus');
    }

    public function account(){
        return $this->belongsTo('App\Account');
    }

    public function user(){
        return $this->belongsTo('App\User');
    }

    public function activities(){
        return $this->hasMany('App\Contact');
    }

}

A continuación, abra el app/ContactSource.phparchivo y actualice en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class ContactSource extends Model
{
    public function contacts(){
        $this->hasMany('App\Contact');
    }
}

A continuación, abra el app/ContactStatus.phparchivo y actualice en consecuencia:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class ContactStatus extends Model
{
    //
    public function contacts(){
        $this->hasMany('App\Contact');
    }
}

Finalmente, abra el app/User.phparchivo y actualice de la siguiente manera:

<?php

namespace App;

use Illuminate\Notifications\Notifiable;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'email', 'password',
    ];

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password', 'remember_token',
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];

    public function contacts(){
        $this->hasMany('App\Contact');
    }

    public function activities(){
        return $this->hasMany('App\Activiy');
    }
    public function accounts(){
        return $this->hasMany('App\Account');
    }
}

A continuación, crearemos los controladores de API REST.

Publicar un comentario

0 Comentarios