Eventos y Listeners en Laravel

Contenido del curso

Laravel y Base de Datos

Entorno de trabajo y repaso de Laravel

Manejo de tu base de datos con Laravel

La terminal de Laravel

Eventos y tareas de Laravel

Manejo de errores

El corazón de Laravel

Creación de paquetes

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:40

Eventos y Listeners en Laravel

Curso Avanzado de Laravel

Clase 13 de 33

Clase 13 / 33

Recursos

Aprende a usar eventos y listeners en Laravel para automatizar acciones clave: crear un evento cuando un producto es calificado, dispararlo desde un tray y responder con un email de notificación. Verás cómo intervienen EventServiceProvider, el arreglo listen, el helper event, el constructor del evento, el método broadcastOn y los getters.

¿Qué es el manejo de eventos en Laravel y para qué sirve?

Los eventos permiten reaccionar a acciones del usuario dentro del ciclo de vida de la aplicación. Cada acción (clic, teclas) genera un objeto de evento, y un listener captura ese evento para ejecutar lógica.

Evento: representa una acción iniciada por el usuario y crea un objeto nuevo.
Listener: clase que escucha eventos específicos y ejecuta una acción.
Ciclo de vida: el sistema puede disparar eventos en distintos puntos.

¿Dónde se registran en EventServiceProvider?

El corazón está en EventServiceProvider dentro de app/providers. Ahí, el arreglo listen mapea eventos con listeners. Ya existe un ejemplo: cuando se registra un usuario, se envía un email de verificación. Ese patrón guía el registro de tus propios eventos.

¿Qué hace un listener y cuándo actúa?

Un listener tiene un constructor para inyectar servicios y un método handle con la lógica. Escucha un evento específico y se ejecuta cuando ese evento se dispara.

¿Cómo crear y estructurar un evento personalizado en Laravel?

Primero se crea el evento con PHP Artisan make event. En el caso explicado, se define un evento para cuando se califique una entidad, llamado "model rated". El archivo queda en la carpeta events y contiene un constructor y el método broadcast on (no usado por ahora).

Recibe: el modelo del calificador, el modelo del producto calificado y el score de la calificación.
Declara propiedades e inicializa en el constructor.
Implementa getters para recuperar datos al transmitir el evento.

Luego se añade el disparo del evento al tray "can rate". Dentro del método "rate", después de completar la operación, se dispara con el helper event creando una instancia de "model rate rated" con: el calificador (this), el modelo calificado (parámetro) y el score.

¿Dónde y cómo dispararlo con el helper event?

Se coloca el disparo al final del método "rate" del tray. Se usa el helper event con la nueva instancia del evento y los tres datos: quien califica, el modelo calificado y la puntuación.

¿Cómo escuchar el evento y enviar una notificación por email?

Se crea un listener con php artisan make listener para enviar un correo a quienes hayan creado productos cuando estos sean calificados. El listener recibe solo el evento "model rated" y en el método handle ejecuta la lógica.

Obtiene el ratable desde el evento usando el getter. Corrige el nombre a "ratable" si es necesario.
Verifica si es instancia de producto para actuar solo en ese caso.
Crea una notificación y la envía al usuario creador del producto vía la relación "created by" con notify.

¿Qué incluye la notificación por correo?

Se crea con PHP Artisan mail notification. La notificación recibe tres datos: el nombre del calificador, el nombre del producto y el score. El email muestra un mensaje como: "[nombre] ha calificado tu producto [producto] con [score] estrellas". Ejemplo: "Sergio ha calificado tu producto Sarasa con cinco estrellas".

Propiedades: qualifier name (string), product name, score.
Constructor: inicializa dichas propiedades.
Contenido del email: mensaje personalizado con esos datos.

¿Cómo registrar el mapeo evento-listener?

Con el evento y el listener listos, se registran en EventServiceProvider dentro del arreglo listen: el evento "Model rated Class" y su listener "Send email model rated notification". Tras esto, solo queda probar.

¿Te animas a implementar el evento "un rate model" que se dispara cuando un usuario califica un producto? Comparte tus dudas o avances en los comentarios.

Brian Sánchez Izquierdo

Hace 6 años

Comparto mi solución al reto: Primera parte - Prueba de Unrate Siguiendo TDD primero creamos una prueba para testear que un usuario en efecto pueda quitar su calificación de un producto:

public function test_unrating_model()
    {
        $this->withoutExceptionHandling();
        $user = User::factory()->create();
        $product = Product::factory()->create();

        $user->rate( $product, 5 );

        $user->unrate( $product );

        $rating = Rating::first();

        $this->assertEmpty( $rating );
    }

Creamos un usuario y un producto, le damos un calificación y luego la borramos, comprobamos que ya no exista más esa calificación, les dejo el commit en mi repositorio: test_unrating_model . Segunda parte - método unrate del Trait CanRate Como los usuarios tiene el trait CanRate, hace sentido que definamos el método para borrar calificación dentro de esa clase:

public function unrate( Model $model )
    {
        // $rating = \App\Models\Rating::query()
        //                             ->where( 'qualifier_id', $this->id )
        //                             ->where( 'rateable_id', $model->id )
        //                             ->first();

        // $rating->delete();

        $this->ratings( $model->getMorphClass() )->detach( $model->getKey() );

        event( new ModelUnrated( $this, $model ) );

        return true;
    }

llegué a una solución diferente a la que el profe, pero me pareció más elegante la de él por lo que la usé también, cabe aclarar que en este método dispararemos el evento del reto. Dejo el commit de mi repositorio: método unrate . Tercera parte - creación del evento Pues creamos el evento que guardara y expondrá el nombre del qualifier (quien quitó su calificación) y el nombre del rateable (producto al cual se le quitó calificación):

<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class ModelUnrated
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $qualifier;
    public $rateable;

    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct( Model $qualifier, Model $rateable )
    {
        $this->qualifier = $qualifier;
        $this->rateable = $rateable;
    }

    public function getQualifier(): Model
    {
        return $this->qualifier;
    }

    public function getRateable(): Model
    {
        return $this->rateable;
    }

    /**
     * Get the channels the event should broadcast on.
     *
     * @return \Illuminate\Broadcasting\Channel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}

. Cuarta parte - Creación del Listener Vamos a crear el Listener que se encargara de atender el evento cuando este se dispare, para enviar una notificación por email que informe el nombre de quien quitó su calificación y a que producto:

<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class ModelUnrated
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $qualifier;
    public $rateable;

    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct( Model $qualifier, Model $rateable )
    {
        $this->qualifier = $qualifier;
        $this->rateable = $rateable;
    }

    public function getQualifier(): Model
    {
        return $this->qualifier;
    }

    public function getRateable(): Model
    {
        return $this->rateable;
    }

    /**
     * Get the channels the event should broadcast on.
     *
     * @return \Illuminate\Broadcasting\Channel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}

les dejo el commit en mi repositorio: creación de listener

. Quinta parte - Creación de la notificación creamos una notificación donde el constructor guarda los valores anteriormente mencionados en variable privadas y redactamos el contenido del correo:

<?php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class ModelUnratedNotification extends Notification
{
    use Queueable;

    private $qualifierName;
    private $rateableName;

    /**
     * Create a new notification instance.
     *
     * @return void
     */
    public function __construct( string $qualifierName, string $rateableName )
    {
        $this->qualifierName = $qualifierName;
        $this->rateableName = $rateableName;
    }

    /**
     * Get the notification's delivery channels.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function via($notifiable)
    {
        return ['mail'];
    }

    /**
     * Get the mail representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return \Illuminate\Notifications\Messages\MailMessage
     */
    public function toMail($notifiable)
    {
        return (new MailMessage)
                    ->line( "El usuario {$this->qualifierName} ha removido su calificación de tu producto {$this->rateableName}" );
    }

    /**
     * Get the array representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function toArray($notifiable)
    {
        return [
            //
        ];
    }
}

Les dejo el commit de mi repositorio: notificación . Sexta parte - Declaramos el evento y el listener en Laravel

ModelUnrated::class => [
            SendEmailModelUnratedNotification::class
        ]
        ]

y estamos listos para seguir!

Comentarios (15)15 comentarios

Fernando Mejia

Mariano Gastón Paduani

Hace 5 años

Gustavo Martínez

Hace 4 años

Jose Luis Arellano

Agustin Erwin Sigfrido Devesa

Juan Guillermo Perez Cardozo

Alejandro Madrid Felizzola

Regynald Zambrano

Carlos Eduardo Gomez García

Luis Cano

Kenneth Angulo L

Hace 2 años

Juan David Rueda Quiroga

Hace 3 años

Joel alexander

Néstor Iván Cepeda Munevar

Jean Nuñez

Tomas Goldenberg

Earvin Saúl Pérez Ramos

Laravel y Base de Datos

Entorno de trabajo y repaso de Laravel

Qué aprenderás sobre Laravel Avanzado

Instalación de Laravel con Composer

Configuración SQLite y API productos Laravel

Instalación, configuración y uso de Homestead

Instalar Laravel Sanctum

Tipos de autenticación en Laravel

Manejo de tu base de datos con Laravel

API Resource Laravel para JSON preciso

Manejo de relaciones en bases de datos con Laravel

Cómo usar relaciones polimórficas en Laravel

La terminal de Laravel

Comandos personalizados en Laravel con Artisan

Ejecutando comandos desde la API

Programación de tareas

Eventos y tareas de Laravel

Eventos y Listeners en Laravel

Eventos de Eloquent

Queues y jobs en Laravel con driver database

Listeners a jobs con JobQueue en Laravel

Laravel Horizon

Manejo de errores

Cómo capturar y leer errores con la clase Handler

Excepciones personalizadas

Manejo de excepciones HTTP con abort en Laravel

Configuración de logs y channels en Laravel

El corazón de Laravel

Ciclo de vida de una aplicación en Laravel

Qué es el service container de Laravel

¿Cómo funciona un service container?

Service providers: cargar componentes sin instanciar

Creación de paquetes

Cómo crear paquetes Laravel con Composer

Propiedades para manejo de dependencias

Comprende el archivo composer.json

Cómo Composer carga clases automáticamente

Crear mis propios Services Providers

Cómo publicar archivos con Service Provider

Instalando paquetes desde GitHub con Composer

Publicar tu paquete PHP en Packages

Eventos y Listeners en Laravel