Notificaciones en Laravel 10.x: Creación y Envío de Notificaciones

Introducción
Generación de notificaciones
Envío de notificaciones
Notificaciones por correo electrónico
Notificaciones por correo con formato Markdown
Notificaciones por base de datos
Notificaciones por transmisión
Notificaciones por SMS
Notificaciones por Slack
Localización de notificaciones
Pruebas
Eventos de notificaciones
Canales personalizados

Introducción

Además del soporte para enviar correos electrónicos, Laravel proporciona soporte para enviar notificaciones a través de una variedad de canales de entrega, que incluyen correo electrónico, SMS (a través de Vonage, anteriormente conocido como Nexmo), y Slack. Además, se han creado una variedad de canales de notificación creados por la comunidad para enviar notificaciones a través de docenas de canales diferentes. Las notificaciones también se pueden almacenar en una base de datos para que se puedan mostrar en su interfaz web.

Normalmente, las notificaciones deben ser mensajes cortos e informativos que notifiquen a los usuarios algo que ocurrió en su aplicación. Por ejemplo, si está escribiendo una aplicación de facturación, podría enviar una notificación de "Factura pagada" a sus usuarios a través de los canales de correo electrónico y SMS.

Generación de notificaciones

En Laravel, cada notificación está representada por una única clase que generalmente se almacena en el directorio app/Notifications. No se preocupe si no ve este directorio en su aplicación; se creará para usted cuando ejecute el comando Artisan make:notification:

php artisan make:notification InvoicePaid

Este comando colocará una nueva clase de notificación en su directorio app/Notifications. Cada clase de notificación contiene un método via y un número variable de métodos de construcción de mensajes, como toMail o toDatabase, que convierten la notificación en un mensaje adaptado para ese canal en particular.

Envío de notificaciones

Uso del rasgo Notifiable

Las notificaciones se pueden enviar de dos maneras: usando el método notify del rasgo Notifiable o usando el facade Notification. El rasgo Notifiable se incluye en el modelo App\Models\User de su aplicación de forma predeterminada:

<?php
 
namespace App\Models;
 
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
 
class User extends Authenticatable
{
    use Notifiable;
}

El método notify proporcionado por este rasgo espera recibir una instancia de notificación:

use App\Notifications\InvoicePaid;
 
$user->notify(new InvoicePaid($invoice));

Nota Recuerde que puede utilizar el rasgo Notifiable en cualquiera de sus modelos. No está limitado a incluirlo solo en su modelo User.

Uso del Facade de notificación

Alternativamente, puede enviar notificaciones inmediatamente utilizando el facade Notification. Este enfoque es útil cuando necesita enviar una notificación a varias entidades notificables, como una colección de usuarios. Para enviar notificaciones utilizando el facade, pase todas las entidades notificables y la instancia de notificación al método send:

use Illuminate\Support\Facades\Notification;
 
Notification::send($users, new InvoicePaid($invoice));

También puede enviar notificaciones inmediatamente utilizando el método sendNow. Este método enviará la notificación inmediatamente incluso si la notificación implementa la interfaz ShouldQueue:

Notification::sendNow($developers, new DeploymentCompleted($deployment));

Especificación de canales de entrega

Cada clase de notificación tiene un método via que determina en qué canales se entregará la notificación. Las notificaciones se pueden enviar en los canales mail, database, broadcast, vonage y slack.

Nota Si desea utilizar otros canales de entrega como Telegram o Pusher, consulte el sitio web de Laravel Notification Channels, impulsado por la comunidad.

El método via recibe una instancia de $notifiable, que será una instancia de la clase a la que se enviará la notificación. Puede usar $notifiable para determinar en qué canales se debe entregar la notificación:

/**
 * Obtener los canales de entrega de la notificación.
 *
 * @return array<int, string>
 */
public function via(object $notifiable): array
{
    return $notifiable->prefers_sms ? ['vonage'] : ['mail', 'database'];
}

Cola de notificaciones

Advertencia Antes de encolar notificaciones, debe configurar su cola y iniciar un worker.

Enviar notificaciones puede llevar tiempo, especialmente si el canal necesita hacer una llamada de API externa para entregar la notificación. Para acelerar el tiempo de respuesta de su aplicación, permita que su notificación esté en cola agregando la interfaz ShouldQueue y el rasgo Queueable a su clase. La interfaz y el rasgo ya están importados para todas las notificaciones generadas utilizando el comando make:notification, por lo que puede agregarlos de inmediato a su clase de notificación:

<?php
 
namespace App\Notifications;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
 
class InvoicePaid extends Notification implements ShouldQueue
{
    use Queueable;
 
    // ...
}

Una vez que se haya agregado la interfaz ShouldQueue a su notificación, puede enviar la notificación como de costumbre. Laravel detectará la interfaz ShouldQueue en la clase y encolará automáticamente la entrega de la notificación:

$user->notify(new InvoicePaid($invoice));

Al encolar notificaciones, se creará un trabajo en cola para cada combinación de destinatario y canal. Por ejemplo, se enviarán seis trabajos a la cola si su notificación tiene tres destinatarios y dos canales.

Retraso de notificaciones

Si desea retrasar la entrega de la notificación, puede encadenar el método delay en la instancia de su notificación:

$delay = now()->addMinutes(10);
 
$user->notify((new InvoicePaid($invoice))->delay($delay));

Retraso de notificaciones por canal

Puede pasar un array al método delay para especificar el tiempo de espera para canales específicos:

$user->notify((new InvoicePaid($invoice))->delay([
    'mail' => now()->addMinutes(5),
    'sms' => now()->addMinutes(10),
]));

Alternativamente, puede definir un método withDelay en la propia clase de notificación. El método withDelay debe devolver un array de nombres de canal y valores de retraso:

/**
 * Determinar el retraso de entrega de la notificación.
 *
 * @return array<string, \Illuminate\Support\Carbon>
 */
public function withDelay(object $notifiable): array
{
    return [
        'mail' => now()->addMinutes(5),
        'sms' => now()->addMinutes(10),
    ];
}

Personalización de la conexión de la cola de notificaciones

De forma predeterminada, las notificaciones en cola se encolarán utilizando la conexión de cola predeterminada de su aplicación. Si desea especificar una conexión diferente que se debe usar para una notificación en particular, puede llamar al método onConnection desde el constructor de su notificación:

<?php
 
namespace App\Notifications;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
 
class InvoicePaid extends Notification implements ShouldQueue
{
    use Queueable;
 
    /**
     * Crear una nueva instancia de notificación.
     */
    public function __construct()
    {
        $this->onConnection('redis');
    }
}

O, si desea especificar una conexión de cola específica que se debe usar para cada canal de notificación admitido por la notificación, puede definir un método viaConnections en su notificación. Este método debe devolver un array de pares de nombres de canal / nombres de conexión de cola:

/**
 * Determinar qué conexiones deben usarse para cada canal de notificación.
 *
 * @return array<string, string>
 */
public function viaConnections(): array
{
    return [
        'mail' => 'redis',
        'database' => 'sync',
    ];
}

Personalización de colas de canales de notificación

Si desea especificar una cola específica que se debe usar para cada canal de notificación admitido por la notificación, puede definir un método viaQueues en su notificación. Este método debe devolver un array de pares de nombres de canal / nombres de cola:

/**
 * Determinar qué colas deben usarse para cada canal de notificación.
 *
 * @return array<string, string>
 */
public function viaQueues(): array
{
    return [
        'mail' => 'mail-queue',
        'slack' => 'slack-queue',
    ];
}

Notificaciones en cola y transacciones de base de datos

Cuando las notificaciones en cola se despachan dentro de transacciones de base de datos, pueden procesarse en la cola antes de que se haya confirmado la transacción de base de datos. Cuando esto sucede, las actualizaciones que haya realizado en los modelos o registros de la base de datos durante la transacción de base de datos es posible que aún no se reflejen en la base de datos. Además, es posible que los modelos o registros de la base de datos creados dentro de la transacción aún no existan en la base de datos. Si su notificación depende de estos modelos, pueden ocurrir errores inesperados cuando se procesa el trabajo que envía la notificación en cola.

Si la opción de configuración after_commit de su conexión de cola está configurada como false, aún puede indicar que una notificación en cola específica debe despacharse después de que se hayan confirmado todas las transacciones de base de datos abiertas llamando al método afterCommit al enviar la notificación:

use App\Notifications\InvoicePaid;
 
$user->notify((new InvoicePaid($invoice))->afterCommit());

Alternativamente, puede llamar al método afterCommit desde el constructor de su notificación:

<?php
 
namespace App\Notifications;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
 
class InvoicePaid extends Notification implements ShouldQueue
{
    use Queueable;
 
    /**
     * Crear una nueva instancia de notificación.
     */
    public function __construct()
    {
        $this->afterCommit();
    }
}

Nota Para obtener más información sobre cómo solucionar estos problemas, revise la documentación sobre trabajos en cola y transacciones de base de datos.

Determinar si debe enviarse una notificación en cola

Después de que una notificación en cola se haya despachado para la cola de procesamiento en segundo plano, normalmente será aceptada por un trabajador de la cola y se enviará a su destinatario previsto.

Sin embargo, si desea tomar la determinación final de si la notificación en cola debe enviarse después de que sea procesada por un trabajador de la cola, puede definir un método shouldSend en la clase de notificación. Si este método devuelve false, la notificación no se enviará:

/**
 * Determinar si se debe enviar la notificación.
 */
public function shouldSend(object $notifiable, string $channel): bool
{
    return $this->invoice->isPaid();
}

Notificaciones a petición

A veces, es posible que necesite enviar una notificación a alguien que no esté almacenado como un "usuario" de su aplicación. Utilizando el método route del facade Notification, puede especificar información de enrutamiento de notificación ad hoc antes de enviar la notificación:

use Illuminate\Broadcasting\Channel;
use Illuminate\Support\Facades\Notification;
 
Notification::route('mail', '[email protected]')
            ->route('vonage', '5555555555')
            ->route('slack', '#slack-channel')
            ->route('broadcast', [new Channel('channel-name')])
            ->notify(new InvoicePaid($invoice));

Si desea proporcionar el nombre del destinatario al enviar una notificación bajo demanda a la ruta mail, puede proporcionar un array que contenga la dirección de correo electrónico como clave y el nombre como valor del primer elemento en el array:

Notification::route('mail', [
    '[email protected]' => 'Barrett Blair',
])->notify(new InvoicePaid($invoice));

Notificaciones por correo electrónico

Formato de mensajes de correo

Si una notificación admite ser enviada como correo electrónico, debe definir un método toMail en la clase de notificación. Este método recibirá una entidad $notifiable y debe devolver una instancia de Illuminate\Notifications\Messages\MailMessage.

La clase MailMessage contiene algunos métodos simples para ayudarlo a construir mensajes de correo electrónico transaccionales. Los mensajes de correo pueden contener líneas de texto y un "llamado a la acción". Echemos un vistazo a un ejemplo del método toMail:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    $url = url('/invoice/'.$this->invoice->id);
 
    return (new MailMessage)
                ->greeting('Hello!')
                ->line('One of your invoices has been paid!')
                ->lineIf($this->amount > 0, "Amount paid: {$this->amount}")
                ->action('View Invoice', $url)
                ->line('Thank you for using our application!');
}

Nota Tenga en cuenta que estamos utilizando $this->invoice->id en nuestro método toMail. Puede pasar cualquier dato que su notificación necesite para generar su mensaje en el constructor de la notificación.

En este ejemplo, registramos un saludo, una línea de texto, un llamado a la acción y luego otra línea de texto. Estos métodos proporcionados por el objeto MailMessage hacen que sea simple y rápido formatear pequeños correos electrónicos transaccionales. El canal de correo luego traducirá los componentes del mensaje en una plantilla de correo electrónico HTML hermosa y receptiva con una contraparte de texto sin formato. Aquí hay un ejemplo de un correo electrónico generado por el canal mail:

Nota Al enviar notificaciones por correo, asegúrese de establecer la opción de configuración name en el archivo de configuración config/app.php. Este valor se utilizará en el encabezado y pie de sus mensajes de notificación por correo.

Mensajes de error

Algunas notificaciones informan a los usuarios sobre errores, como un pago de factura fallido. Puede indicar que un mensaje de correo electrónico se refiere a un error llamando al método error al construir su mensaje. Cuando se usa el método error en un mensaje de correo, el botón de llamada a la acción será rojo en lugar de negro:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->error()
                ->subject('Invoice Payment Failed')
                ->line('...');
}

Otras opciones de formato de notificaciones por correo

En lugar de definir las "líneas" de texto en la clase de notificación, puede usar el método view para especificar una plantilla personalizada que se utilizará para representar el correo electrónico de notificación:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)->view(
        'emails.name', ['invoice' => $this->invoice]
    );
}

Puede especificar una vista de texto sin formato para el mensaje de correo pasando el nombre de la vista como el segundo elemento de un array que se da al método view:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)->view(
        ['emails.name.html', 'emails.name.plain'],
        ['invoice' => $this->invoice]
    );
}

Personalización del remitente

De forma predeterminada, la dirección del remitente/de se define en el archivo de configuración config/mail.php. Sin embargo, puede especificar la dirección del remitente para una notificación específica mediante el método from:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->from('[email protected]', 'Barrett Blair')
                ->line('...');
}

Personalización del destinatario

Al enviar notificaciones a través del canal mail, el sistema de notificación buscará automáticamente una propiedad email en su entidad notificable. Puede personalizar qué dirección de correo electrónico se utiliza para entregar la notificación definiendo un método routeNotificationForMail en la entidad notificable:

<?php
 
namespace App\Models;
 
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Notifications\Notification;
 
class User extends Authenticatable
{
    use Notifiable;
 
    /**
     * Enrutar notificaciones para el canal de correo electrónico.
     *
     * @return  array<string, string>|string
     */
    public function routeNotificationForMail(Notification $notification): array|string
    {
        // Devolver solo la dirección de correo electrónico...
        return $this->email_address;
 
        // Devolver la dirección de correo electrónico y el nombre...
        return [$this->email_address => $this->name];
    }
}

Personalización del asunto

De forma predeterminada, el asunto del correo electrónico es el nombre de la clase de la notificación formateado en "Title Case". Entonces, si la clase de su notificación se llama InvoicePaid, el asunto del correo electrónico será Invoice Paid. Si desea especificar un asunto diferente para el mensaje, puede llamar al método subject al construir su mensaje:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->subject('Notification Subject')
                ->line('...');
}

Personalización del remitente de correo

De forma predeterminada, la notificación de correo electrónico se enviará utilizando el remitente de correo electrónico predeterminado definido en el archivo de configuración config/mail.php. Sin embargo, puede especificar un remitente de correo electrónico diferente en tiempo de ejecución llamando al método mailer al construir su mensaje:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->mailer('postmark')
                ->line('...');
}

Personalización de las plantillas

Puede modificar la plantilla HTML y de texto sin formato utilizada por las notificaciones de correo publicando los recursos del paquete de notificaciones. Después de ejecutar este comando, las plantillas de notificación de correo se encontrarán en el directorio resources/views/vendor/notifications:

php artisan vendor:publish --tag=laravel-notifications

Adjuntos

Para agregar archivos adjuntos a una notificación por correo electrónico, utilice el método attach al construir su mensaje. El método attach acepta la ruta absoluta del archivo como su primer argumento:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->greeting('Hello!')
                ->attach('/path/to/file');
}

Nota El método attach ofrecido por los mensajes de correo de notificación también acepta objetos adjuntos. Consulte la completa documentación de objetos adjuntos para obtener más información.

Al adjuntar archivos a un mensaje, también puede especificar el nombre de visualización y/o el tipo MIME pasando un array como segundo argumento al método attach:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->greeting('Hello!')
                ->attach('/path/to/file', [
                    'as' => 'name.pdf',
                    'mime' => 'application/pdf',
                ]);
}

A diferencia de adjuntar archivos en objetos de correo electrónico, no puede adjuntar un archivo directamente desde un disco de almacenamiento utilizando attachFromStorage. En su lugar, debería usar el método attach con la ruta absoluta del archivo en el disco de almacenamiento. Alternativamente, podría devolver un mailable desde el método toMail:

use App\Mail\InvoicePaid as InvoicePaidMailable;
 
/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): Mailable
{
    return (new InvoicePaidMailable($this->invoice))
                ->to($notifiable->email)
                ->attachFromStorage('/path/to/file');
}

Cuando sea necesario, se pueden adjuntar varios archivos a un mensaje mediante el método attachMany:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->greeting('Hello!')
                ->attachMany([
                    '/path/to/forge.svg',
                    '/path/to/vapor.svg' => [
                        'as' => 'Logo.svg',
                        'mime' => 'image/svg+xml',
                    ],
                ]);
}

Adjuntos de datos sin procesar

El método attachData se puede utilizar para adjuntar una cadena de bytes sin procesar como un archivo adjunto. Al llamar al método attachData, debe proporcionar el nombre de archivo que se asignará al archivo adjunto:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->greeting('Hello!')
                ->attachData($this->pdf, 'name.pdf', [
                    'mime' => 'application/pdf',
                ]);
}

Agregar etiquetas y metadatos

Algunos proveedores de correo electrónico de terceros, como Mailgun y Postmark, admiten "etiquetas" y "metadatos" de mensajes, que se pueden usar para agrupar y realizar un seguimiento de los correos electrónicos enviados por su aplicación. Puede agregar etiquetas y metadatos a un mensaje de correo electrónico mediante los métodos tag y metadata:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->greeting('Comment Upvoted!')
                ->tag('upvote')
                ->metadata('comment_id', $this->comment->id);
}

Si su aplicación está utilizando el controlador de Mailgun, puede consultar la documentación de Mailgun para obtener más información sobre etiquetas y metadatos. De manera similar, la documentación de Postmark también se puede consultar para obtener más información sobre su compatibilidad con etiquetas y metadatos.

Si su aplicación está utilizando Amazon SES para enviar correos electrónicos, debe usar el método metadata para adjuntar etiquetas SES al mensaje.

Personalización del mensaje Symfony

El método withSymfonyMessage de la clase MailMessage le permite registrar un cierre que se invocará con la instancia de mensaje Symfony antes de enviar el mensaje. Esto le brinda la oportunidad de personalizar profundamente el mensaje antes de que se entregue:

use Symfony\Component\Mime\Email;
 
/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->withSymfonyMessage(function (Email $message) {
                    $message->getHeaders()->addTextHeader(
                        'Custom-Header', 'Header Value'
                    );
                });
}

Uso de Mailables

Si es necesario, puede devolver un objeto mailable completo desde el método toMail de su notificación. Cuando devuelve un Mailable en lugar de un MailMessage, deberá especificar el destinatario del mensaje utilizando el método to del objeto mailable:

use App\Mail\InvoicePaid as InvoicePaidMailable;
use Illuminate\Mail\Mailable;
 
/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): Mailable
{
    return (new InvoicePaidMailable($this->invoice))
                ->to($notifiable->email);
}

Mailables y notificaciones a petición

Si está enviando una notificación bajo demanda, la instancia $notifiable dada al método toMail será una instancia de Illuminate\Notifications\AnonymousNotifiable, que ofrece un método routeNotificationFor que se puede utilizar para recuperar la dirección de correo electrónico a la que se debe enviar la notificación bajo demanda:

use App\Mail\InvoicePaid as InvoicePaidMailable;
use Illuminate\Notifications\AnonymousNotifiable;
use Illuminate\Mail\Mailable;
 
/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): Mailable
{
    $address = $notifiable instanceof AnonymousNotifiable
            ? $notifiable->routeNotificationFor('mail')
            : $notifiable->email;
 
    return (new InvoicePaidMailable($this->invoice))
                ->to($address);
}

Vista previa de notificaciones por correo

Cuando diseñe una plantilla de notificación de correo, es conveniente previsualizar rápidamente el mensaje de correo renderizado en su navegador, al igual que una plantilla Blade típica. Por esta razón, Laravel le permite devolver cualquier mensaje de correo generado por una notificación directamente desde un cierre de ruta o controlador. Cuando se devuelve un MailMessage, se renderizará y mostrará en el navegador, lo que le permite previsualizar rápidamente su diseño sin necesidad de enviarlo a una dirección de correo electrónico real:

use App\Models\Invoice;
use App\Notifications\InvoicePaid;
 
Route::get('/notification', function () {
    $invoice = Invoice::find(1);
 
    return (new InvoicePaid($invoice))
                ->toMail($invoice->user);
});

Notificaciones por correo con formato Markdown

Las notificaciones de correo electrónico de Markdown le permiten aprovechar las plantillas preconstruidas de las notificaciones de correo electrónico, al tiempo que le brindan más libertad para escribir mensajes más largos y personalizados. Dado que los mensajes están escritos en Markdown, Laravel puede renderizar plantillas HTML hermosas y receptivas para los mensajes, al tiempo que genera automáticamente una contraparte de texto sin formato.

Generación del mensaje

Para generar una notificación con una plantilla de Markdown correspondiente, puede usar la opción --markdown del comando Artisan make:notification:

php artisan make:notification InvoicePaid --markdown=mail.invoice.paid

Al igual que todas las demás notificaciones de correo, las notificaciones que usan plantillas de Markdown deben definir un método toMail en su clase de notificación. Sin embargo, en lugar de usar los métodos line y action para construir la notificación, use el método markdown para especificar el nombre de la plantilla de Markdown que se debe usar. Se puede pasar un array de datos que desea poner a disposición de la plantilla como segundo argumento del método:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    $url = url('/invoice/'.$this->invoice->id);
 
    return (new MailMessage)
                ->subject('Invoice Paid')
                ->markdown('mail.invoice.paid', ['url' => $url]);
}

Escritura del mensaje

Las notificaciones de correo electrónico de Markdown utilizan una combinación de componentes Blade y sintaxis de Markdown que le permiten construir fácilmente notificaciones mientras aprovechan los componentes de notificación preconstruidos de Laravel:

<x-mail::message>
# Invoice Paid
 
Your invoice has been paid!
 
<x-mail::button :url="$url">
View Invoice
</x-mail::button>
 
Thanks,<br>
{{ config('app.name') }}
</x-mail::message>

Componente de botón

El componente de botón renderiza un enlace de botón centrado. El componente acepta dos argumentos, una url y un color opcional. Los colores admitidos son primary, green y red. Puede agregar tantos componentes de botón a una notificación como desee:

<x-mail::button :url="$url" color="green">
View Invoice
</x-mail::button>

Componente de panel

El componente de panel renderiza el bloque de texto dado en un panel que tiene un color de fondo ligeramente diferente al resto de la notificación. Esto le permite llamar la atención sobre un bloque de texto dado:

<x-mail::panel>
This is the panel content.
</x-mail::panel>

Componente de tabla

El componente de tabla le permite transformar una tabla de Markdown en una tabla HTML. El componente acepta la tabla de Markdown como su contenido. Se admite la alineación de columnas de la tabla mediante la sintaxis de alineación de tabla Markdown predeterminada:

<x-mail::table>
| Laravel       | Table         | Example  |
| ------------- |:-------------:| --------:|
| Col 2 is      | Centered      | $10      |
| Col 3 is      | Right-Aligned | $20      |
</x-mail::table>

Personalización de los componentes

Puede exportar todos los componentes de notificación de Markdown a su propia aplicación para personalización. Para exportar los componentes, use el comando Artisan vendor:publish para publicar la etiqueta de activo laravel-mail:

php artisan vendor:publish --tag=laravel-mail

Este comando publicará los componentes de correo electrónico de Markdown en el directorio resources/views/vendor/mail. El directorio mail contendrá un directorio html y un directorio text, cada uno con sus respectivas representaciones de todos los componentes disponibles. Puede personalizar estos componentes como desee.

Personalización del CSS

Después de exportar los componentes, el directorio resources/views/vendor/mail/html/themes contendrá un archivo default.css. Puede personalizar el CSS en este archivo y sus estilos se incluirán automáticamente en las representaciones HTML de sus notificaciones de Markdown.

Si desea construir un tema completamente nuevo para los componentes de Markdown de Laravel, puede colocar un archivo CSS dentro del directorio html/themes. Después de nombrar y guardar su archivo CSS, actualice la opción theme del archivo de configuración mail para que coincida con el nombre de su nuevo tema.

Para personalizar el tema para una notificación individual, puede llamar al método theme al construir el mensaje de correo de la notificación. El método theme acepta el nombre del tema que se debe usar al enviar la notificación:

/**
 * Obtener la representación de correo electrónico de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->theme('invoice')
                ->subject('Invoice Paid')
                ->markdown('mail.invoice.paid', ['url' => $url]);
}

Notificaciones por base de datos

Prerrequisitos

El canal de notificación database almacena la información de la notificación en una tabla de base de datos. Esta tabla contendrá información como el tipo de notificación, así como una estructura de datos JSON que describe la notificación.

Puede consultar la tabla para mostrar las notificaciones en la interfaz de usuario de su aplicación. Pero, antes de poder hacer eso, deberá crear una tabla de base de datos para almacenar sus notificaciones. Puede usar el comando notifications:table para generar una migración con el esquema adecuado para la tabla:

php artisan notifications:table
 
php artisan migrate

Nota Si sus modelos notificables utilizan claves primarias UUID o ULID, debe reemplazar el método morphs con uuidMorphs o ulidMorphs en la migración de la tabla de notificaciones.

Formato de notificaciones por base de datos

Si una notificación admite ser almacenada en una tabla de base de datos, debe definir un método toDatabase o toArray en la clase de notificación. Este método recibirá una entidad $notifiable y debe devolver un array PHP simple. El array devuelto se codificará como JSON y se almacenará en la columna data de su tabla de notifications. Veamos un ejemplo del método toArray:

/**
 * Obtener la representación de matriz de la notificación.
 *
 * @return array<string, mixed>
 */
public function toArray(object $notifiable): array
{
    return [
        'invoice_id' => $this->invoice->id,
        'amount' => $this->invoice->amount,
    ];
}

`toDatabase` Vs. `toArray`

El método toArray también se utiliza en el canal broadcast para determinar qué datos se deben transmitir a su frontend con JavaScript. Si desea tener dos representaciones de matriz diferentes para los canales database y broadcast, debe definir un método toDatabase en lugar de un método toArray.

Acceso a las notificaciones

Una vez que las notificaciones se almacenan en la base de datos, necesita una forma conveniente de acceder a ellas desde sus entidades notificables. El rasgo Illuminate\Notifications\Notifiable, que se incluye en el modelo predeterminado App\Models\User de Laravel, incluye una relación Eloquent llamada notifications que devuelve las notificaciones para la entidad. Para recuperar notificaciones, puede acceder a este método como cualquier otra relación Eloquent. Por defecto, las notificaciones se ordenarán por la marca de tiempo created_at con las notificaciones más recientes al principio de la colección:

$user = App\Models\User::find(1);
 
foreach ($user->notifications as $notification) {
    echo $notification->type;
}

Si desea recuperar solo las notificaciones "no leídas", puede usar la relación unreadNotifications. Nuevamente, estas notificaciones se ordenarán por la marca de tiempo created_at con las notificaciones más recientes al principio de la colección:

$user = App\Models\User::find(1);
 
foreach ($user->unreadNotifications as $notification) {
    echo $notification->type;
}

Nota Para acceder a sus notificaciones desde su cliente JavaScript, debe definir un controlador de notificaciones para su aplicación que devuelva las notificaciones para una entidad notificable, como el usuario actual. Luego puede realizar una solicitud HTTP a la URL de ese controlador desde su cliente JavaScript.

Marcar notificaciones como leídas

Normalmente, querrá marcar una notificación como "leída" cuando un usuario la vea. El rasgo Illuminate\Notifications\Notifiable proporciona un método markAsRead, que actualiza la columna read_at en el registro de base de datos de la notificación:

$user = App\Models\User::find(1);
 
foreach ($user->unreadNotifications as $notification) {
    $notification->markAsRead();
}

Sin embargo, en lugar de recorrer cada notificación, puede usar el método markAsRead directamente en una colección de notificaciones:

$user->unreadNotifications->markAsRead();

También puede usar una consulta de actualización masiva para marcar todas las notificaciones como leídas sin recuperarlas de la base de datos:

$user = App\Models\User::find(1);
 
$user->unreadNotifications()->update(['read_at' => now()]);

Puede delete las notificaciones para eliminarlas completamente de la tabla:

$user->notifications()->delete();

Notificaciones por transmisión

Prerrequisitos

Antes de transmitir notificaciones, debe configurar y estar familiarizado con los servicios de transmisión de eventos de Laravel. La transmisión de eventos proporciona una forma de reaccionar a eventos del lado del servidor desde su frontend con JavaScript.

Formato de notificaciones por transmisión

El canal broadcast transmite notificaciones mediante los servicios de transmisión de eventos de Laravel, lo que permite que su frontend con JavaScript detecte notificaciones en tiempo real. Si una notificación admite la transmisión, puede definir un método toBroadcast en la clase de notificación. Este método recibirá una entidad $notifiable y debe devolver una instancia de BroadcastMessage. Si el método toBroadcast no existe, se utilizará el método toArray para recopilar los datos que se deben transmitir. Los datos devueltos se codificarán como JSON y se transmitirán a su frontend con JavaScript. Veamos un ejemplo del método toBroadcast:

use Illuminate\Notifications\Messages\BroadcastMessage;
 
/**
 * Obtener la representación de transmisión de la notificación.
 */
public function toBroadcast(object $notifiable): BroadcastMessage
{
    return new BroadcastMessage([
        'invoice_id' => $this->invoice->id,
        'amount' => $this->invoice->amount,
    ]);
}

Configuración de la cola de transmisión

Todas las notificaciones de transmisión se encolan para su transmisión. Si desea configurar la conexión o el nombre de la cola que se utiliza para encolar la operación de transmisión, puede usar los métodos onConnection y onQueue de BroadcastMessage:

return (new BroadcastMessage($data))
                ->onConnection('sqs')
                ->onQueue('broadcasts');

Personalización del tipo de notificación

Además de los datos que especifique, todas las notificaciones de transmisión también tienen un campo type que contiene el nombre de clase completo de la notificación. Si desea personalizar el type de notificación, puede definir un método broadcastType en la clase de notificación:

/**
 * Obtener el tipo de la notificación que se va a transmitir.
 */
public function broadcastType(): string
{
    return 'broadcast.message';
}

Escucha de notificaciones

Las notificaciones se transmitirán en un canal privado con el formato {notifiable}.{id}. Entonces, si está enviando una notificación a una instancia App\Models\User con un ID de 1, la notificación se transmitirá en el canal privado App.Models.User.1. Al usar Laravel Echo, puede escuchar fácilmente las notificaciones en un canal usando el método notification:

Echo.private('App.Models.User.' + userId)
    .notification((notification) => {
        console.log(notification.type);
    });

Personalización del canal de notificación

Si desea personalizar en qué canal se transmiten las notificaciones de transmisión de una entidad, puede definir un método receivesBroadcastNotificationsOn en la entidad notificable:

<?php
 
namespace App\Models;
 
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
 
class User extends Authenticatable
{
    use Notifiable;
 
    /**
     * Los canales en los que el usuario recibe transmisiones de notificaciones.
     */
    public function receivesBroadcastNotificationsOn(): string
    {
    }
}

Notificaciones por SMS

Prerrequisitos

El envío de notificaciones por SMS en Laravel está impulsado por Vonage (anteriormente conocido como Nexmo). Antes de poder enviar notificaciones a través de Vonage, debe instalar los paquetes laravel/vonage-notification-channel y guzzlehttp/guzzle:

composer require laravel/vonage-notification-channel guzzlehttp/guzzle

El paquete incluye un archivo de configuración. Sin embargo, no es necesario exportar este archivo de configuración a su propia aplicación. Simplemente puede usar las variables de entorno VONAGE_KEY y VONAGE_SECRET para definir sus claves públicas y secretas de Vonage.

Después de definir sus claves, debe configurar una variable de entorno VONAGE_SMS_FROM que defina el número de teléfono desde el cual se enviarán sus mensajes SMS de forma predeterminada. Puede generar este número de teléfono dentro del panel de control de Vonage:

VONAGE_SMS_FROM=15556666666

Formato de notificaciones por SMS

Si una notificación admite ser enviada como SMS, debe definir un método toVonage en la clase de notificación. Este método recibirá una entidad $notifiable y debe devolver una instancia de Illuminate\Notifications\Messages\VonageMessage:

use Illuminate\Notifications\Messages\VonageMessage;
 
/**
 * Obtener la representación de Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->content('Your SMS message content');
}

Contenido Unicode

Si su mensaje SMS contendrá caracteres Unicode, debe llamar al método unicode al construir la instancia de VonageMessage:

use Illuminate\Notifications\Messages\VonageMessage;
 
/**
 * Obtener la representación de Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->content('Your unicode message')
                ->unicode();
}

Personalización del número "De"

Si desea enviar algunas notificaciones desde un número de teléfono que es diferente al número de teléfono especificado por su variable de entorno VONAGE_SMS_FROM, puede llamar al método from en una instancia de VonageMessage:

use Illuminate\Notifications\Messages\VonageMessage;
 
/**
 * Obtener la representación de Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->content('Your SMS message content')
                ->from('15554443333');
}

Agregar una referencia de cliente

Si desea llevar un seguimiento de los costos por usuario, equipo o cliente, puede agregar una "referencia de cliente" a la notificación. Vonage le permitirá generar informes utilizando esta referencia de cliente para que pueda comprender mejor el uso de SMS de un cliente en particular. La referencia de cliente puede ser cualquier cadena de hasta 40 caracteres:

use Illuminate\Notifications\Messages\VonageMessage;
 
/**
 * Obtener la representación de Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->clientReference((string) $notifiable->id)
                ->content('Your SMS message content');
}

Enrutamiento de notificaciones por SMS

Para enrutar notificaciones de Vonage al número de teléfono correcto, defina un método routeNotificationForVonage en su entidad notificable:

<?php
 
namespace App\Models;
 
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Notifications\Notification;
 
class User extends Authenticatable
{
    use Notifiable;
 
    /**
     * Enrutar notificaciones para el canal Vonage.
     */
    public function routeNotificationForVonage(Notification $notification): string
    {
        return $this->phone_number;
    }
}

Notificaciones por Slack

Prerrequisitos

Antes de enviar notificaciones por Slack, debe instalar el canal de notificación de Slack a través de Composer:

composer require laravel/slack-notification-channel

Además, debe crear una Slack App para su espacio de trabajo de Slack.

Si solo necesita enviar notificaciones al mismo espacio de trabajo de Slack en el que se creó la aplicación, asegúrese de que su aplicación tenga los alcances chat:write, chat:write.public y chat:write.customize. Estos alcances se pueden agregar desde la pestaña de administración de la aplicación "OAuth & Permissions" dentro de Slack.

A continuación, copie el "Token de OAuth de usuario de bot" de la aplicación y colóquelo dentro de un array de configuración slack en el archivo de configuración services.php de su aplicación. Este token se puede encontrar en la pestaña "OAuth & Permissions" dentro de Slack:

'slack' => [
    'notifications' => [
        'bot_user_oauth_token' => env('SLACK_BOT_USER_OAUTH_TOKEN'),
        'channel' => env('SLACK_BOT_USER_DEFAULT_CHANNEL'),
    ],
],

Distribución de la aplicación

Si su aplicación enviará notificaciones a espacios de trabajo de Slack externos que son propiedad de los usuarios de su aplicación, deberá "distribuir" su aplicación a través de Slack. La distribución de la aplicación se puede gestionar desde la pestaña "Gestionar distribución" de su aplicación en Slack. Una vez que su aplicación haya sido distribuida, puede utilizar Socialite para obtener tokens de bot de Slack en nombre de los usuarios de su aplicación.

Formato de notificaciones por Slack

Si una notificación admite ser enviada como un mensaje de Slack, debe definir un método toSlack en la clase de notificación. Este método recibirá una entidad $notifiable y debería devolver una instancia de Illuminate\Notifications\Slack\SlackMessage. Puede construir notificaciones enriquecidas utilizando Slack's Block Kit API. El siguiente ejemplo se puede previsualizar en Slack's Block Kit builder:

use Illuminate\Notifications\Slack\BlockKit\Blocks\ContextBlock;
use Illuminate\Notifications\Slack\BlockKit\Blocks\SectionBlock;
use Illuminate\Notifications\Slack\BlockKit\Composites\ConfirmObject;
use Illuminate\Notifications\Slack\SlackMessage;
 
/**
 * Obtener la representación de Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('One of your invoices has been paid!')
            ->headerBlock('Invoice Paid')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Customer #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('An invoice has been paid.');
                $block->field("*Invoice No:*\n1000")->markdown();
                $block->field("*Invoice Recipient:*\n[email protected]")->markdown();
            })
            ->dividerBlock()
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('Congratulations!');
            });
}

Interactividad de Slack

El sistema de notificación Block Kit de Slack proporciona funciones potentes para manejar la interacción del usuario. Para utilizar estas funciones, su aplicación de Slack debe tener habilitada la "Interactividad" y configurada una "URL de solicitud" que apunte a una URL servida por su aplicación. Estas configuraciones se pueden gestionar desde la pestaña "Interactividad y accesos directos" en la administración de la aplicación en Slack.

En el siguiente ejemplo, que utiliza el método actionsBlock, Slack enviará una solicitud POST a su "URL de solicitud" con un payload que contiene el usuario de Slack que hizo clic en el botón, el ID del botón clicado y más. Su aplicación puede determinar la acción a tomar según el payload. También debe verificar la solicitud fue realizada por Slack:

use Illuminate\Notifications\Slack\BlockKit\Blocks\ActionsBlock;
use Illuminate\Notifications\Slack\BlockKit\Blocks\ContextBlock;
use Illuminate\Notifications\Slack\BlockKit\Blocks\SectionBlock;
use Illuminate\Notifications\Slack\SlackMessage;
 
/**
 * Obtener la representación de Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('One of your invoices has been paid!')
            ->headerBlock('Invoice Paid')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Customer #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('An invoice has been paid.');
            })
            ->actionsBlock(function (ActionsBlock $block) {
                 // El ID predeterminado es "button_acknowledge_invoice"...
                $block->button('Acknowledge Invoice')->primary();
 
                // Configurar manualmente el ID...
                $block->button('Deny')->danger()->id('deny_invoice');
            });
}

Modales de confirmación

Si desea que los usuarios deban confirmar una acción antes de realizarla, puede invocar el método confirm al definir su botón. El método confirm acepta un mensaje y un cierre que recibe una instancia de ConfirmObject:

use Illuminate\Notifications\Slack\BlockKit\Blocks\ActionsBlock;
use Illuminate\Notifications\Slack\BlockKit\Blocks\ContextBlock;
use Illuminate\Notifications\Slack\BlockKit\Blocks\SectionBlock;
use Illuminate\Notifications\Slack\BlockKit\Composites\ConfirmObject;
use Illuminate\Notifications\Slack\SlackMessage;
 
/**
 * Obtener la representación de Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('One of your invoices has been paid!')
            ->headerBlock('Invoice Paid')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Customer #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('An invoice has been paid.');
            })
            ->actionsBlock(function (ActionsBlock $block) {
                $block->button('Acknowledge Invoice')
                    ->primary()
                    ->confirm(
                        'Acknowledge the payment and send a thank you email?',
                        function (ConfirmObject $dialog) {
                            $dialog->confirm('Yes');
                            $dialog->deny('No');
                        }
                    );
            });
}

Inspección de bloques de Slack

Si desea inspeccionar rápidamente los bloques que ha estado construyendo, puede invocar el método dd en la instancia de SlackMessage. El método dd generará y volcará una URL al Constructor de bloques de Slack, que mostrará una vista previa de la carga útil y la notificación en su navegador. Puede pasar true al método dd para volcar la carga útil sin formato:

return (new SlackMessage)
        ->text('One of your invoices has been paid!')
        ->headerBlock('Invoice Paid')
        ->dd();

Enrutamiento de notificaciones por Slack

Para dirigir notificaciones de Slack al equipo y canal de Slack adecuados, defina un método routeNotificationForSlack en su modelo notificable. Este método puede devolver uno de tres valores:

null - que pospone el enrutamiento al canal configurado en la notificación misma. Puede usar el método to al construir su SlackMessage para configurar el canal dentro de la notificación.
Una cadena que especifica el canal de Slack al que se enviará la notificación, por ejemplo, #support-channel.
Una instancia de SlackRoute, que le permite especificar un token de OAuth y un nombre de canal, por ejemplo, SlackRoute::make($this->slack_channel, $this->slack_token). Este método debe usarse para enviar notificaciones a espacios de trabajo externos.

Por ejemplo, devolver #support-channel desde el método routeNotificationForSlack enviará la notificación al canal #support-channel en el espacio de trabajo asociado con el token de OAuth de usuario de bot ubicado en el archivo de configuración services.php de su aplicación:

<?php
 
namespace App\Models;
 
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Notifications\Notification;
 
class User extends Authenticatable
{
    use Notifiable;
 
    /**
     * Enrutar notificaciones para el canal Slack.
     */
    public function routeNotificationForSlack(Notification $notification): mixed
    {
        return '#support-channel';
    }
}

Notificación a espacios de trabajo de Slack externos

Nota Antes de enviar notificaciones a espacios de trabajo de Slack externos, su aplicación de Slack debe estar distribuida.

Por supuesto, a menudo querrá enviar notificaciones a los espacios de trabajo de Slack propiedad de los usuarios de su aplicación. Para hacerlo, primero deberá obtener un token de OAuth de Slack para el usuario. Afortunadamente, Laravel Socialite incluye un controlador de Slack que le permitirá autenticar fácilmente a los usuarios de su aplicación con Slack y obtener un token de bot.

Una vez que haya obtenido el token de bot y lo haya almacenado en la base de datos de su aplicación, puede utilizar el método SlackRoute::make para enrutar una notificación al espacio de trabajo del usuario. Además, es probable que su aplicación necesite ofrecer la oportunidad al usuario de especificar a qué canal se deben enviar las notificaciones:

<?php
 
namespace App\Models;
 
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Slack\SlackRoute;
 
class User extends Authenticatable
{
    use Notifiable;
 
    /**
     * Enrutar notificaciones para el canal Slack.
     */
    public function routeNotificationForSlack(Notification $notification): mixed
    {
        return SlackRoute::make($this->slack_channel, $this->slack_token);
    }
}

Localización de notificaciones

Laravel le permite enviar notificaciones en una configuración regional diferente a la configuración regional actual de la solicitud HTTP, e incluso recordará esta configuración regional si la notificación está en cola.

Para lograr esto, la clase Illuminate\Notifications\Notification ofrece un método locale para establecer el idioma deseado. La aplicación cambiará a esta configuración regional cuando se esté evaluando la notificación y luego volverá a la configuración regional anterior cuando se complete la evaluación:

$user->notify((new InvoicePaid($invoice))->locale('es'));

La localización de varias entradas notificables también se puede lograr a través del facade Notification:

Notification::locale('es')->send(
    $users, new InvoicePaid($invoice)
);

Idiomas preferidos por el usuario

A veces, las aplicaciones almacenan la configuración regional preferida de cada usuario. Al implementar el contrato HasLocalePreference en su modelo notificable, puede indicar a Laravel que utilice esta configuración regional almacenada al enviar una notificación:

use Illuminate\Contracts\Translation\HasLocalePreference;
 
class User extends Model implements HasLocalePreference
{
    /**
     * Obtener la configuración regional preferida del usuario.
     */
    public function preferredLocale(): string
    {
        return $this->locale;
    }
}

Una vez que haya implementado la interfaz, Laravel utilizará automáticamente la configuración regional preferida al enviar notificaciones y correos electrónicos al modelo. Por lo tanto, no es necesario llamar al método locale al usar esta interfaz:

$user->notify(new InvoicePaid($invoice));

Pruebas

Puede usar el método fake del facade Notification para evitar que se envíen notificaciones. Por lo general, enviar notificaciones no está relacionado con el código que realmente está probando. Lo más probable es que sea suficiente con afirmar simplemente que se instruyó a Laravel que enviara una determinada notificación.

Después de llamar al método fake del facade Notification, puede afirmar que se instruyó a enviar notificaciones a los usuarios e incluso inspeccionar los datos que recibieron las notificaciones:

<?php
 
namespace Tests\Feature;
 
use App\Notifications\OrderShipped;
use Illuminate\Support\Facades\Notification;
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_orders_can_be_shipped(): void
    {
        Notification::fake();
 
        // Realizar el envío del pedido...
 
        // Asegurar que no se hayan enviado notificaciones...
        Notification::assertNothingSent();
 
        // Asegurar que se haya enviado una notificación a los usuarios dados...
        Notification::assertSentTo(
            [$user], OrderShipped::class
        );
 
        // Asegurar que no se haya enviado una notificación...
        Notification::assertNotSentTo(
            [$user], AnotherNotification::class
        );
 
        // Asegurar que se haya enviado un número dado de notificaciones...
        Notification::assertCount(3);
    }
}

Puede pasar un cierre al método assertSentTo o assertNotSentTo para afirmar que se envió una notificación que pasa una determinada "prueba de verdad". Si se envió al menos una notificación que supera la prueba de verdad dada, la afirmación será exitosa:

Notification::assertSentTo(
    $user,
    function (OrderShipped $notification, array $channels) use ($order) {
        return $notification->order->id === $order->id;
    }
);

Notificaciones a petición

Si el código que está probando envía notificaciones bajo demanda, puede probar que la notificación bajo demanda se envió mediante el método assertSentOnDemand:

Notification::assertSentOnDemand(OrderShipped::class);

Al pasar un cierre como segundo argumento al método assertSentOnDemand, puede determinar si se envió una notificación bajo demanda a la dirección "ruta" correcta:

Notification::assertSentOnDemand(
    OrderShipped::class,
    function (OrderShipped $notification, array $channels, object $notifiable) use ($user) {
        return $notifiable->routes['mail'] === $user->email;
    }
);

Eventos de notificaciones

Evento de envío de notificaciones

Cuando se envía una notificación, el evento Illuminate\Notifications\Events\NotificationSending se despacha por el sistema de notificaciones. Esto contiene la entidad "notifiable" y la instancia de notificación en sí. Puede registrar escuchadores para este evento en el EventServiceProvider de su aplicación:

use App\Listeners\CheckNotificationStatus;
use Illuminate\Notifications\Events\NotificationSending;
 
/**
 * Las asignaciones de escuchadores de eventos para la aplicación.
 *
 * @var array
 */
protected $listen = [
    NotificationSending::class => [
        CheckNotificationStatus::class,
    ],
];

La notificación no se enviará si un escuchador de eventos para el evento NotificationSending devuelve false desde su método handle:

use Illuminate\Notifications\Events\NotificationSending;
 
/**
 * Handle the event.
 */
public function handle(NotificationSending $event): bool
{
    return false;
}

Dentro de un escuchador de eventos, puede acceder a las propiedades notifiable, notification y channel en el evento para obtener más información sobre el destinatario de la notificación o la notificación en sí:

/**
 * Handle the event.
 */
public function handle(NotificationSending $event): void
{
    // $event->channel
    // $event->notifiable
    // $event->notification
}

Evento de notificación enviada

Cuando se envía una notificación, el evento Illuminate\Notifications\Events\NotificationSent se despacha por el sistema de notificaciones. Esto contiene la entidad "notifiable" y la instancia de notificación en sí. Puede registrar escuchadores para este evento en su EventServiceProvider:

use App\Listeners\LogNotification;
use Illuminate\Notifications\Events\NotificationSent;
 
/**
 * Las asignaciones de escuchadores de eventos para la aplicación.
 *
 * @var array
 */
protected $listen = [
    NotificationSent::class => [
        LogNotification::class,
    ],
];

Nota Después de registrar escuchadores en su EventServiceProvider, use el comando Artisan event:generate para generar rápidamente clases de escuchadores.

Dentro de un escuchador de eventos, puede acceder a las propiedades notifiable, notification, channel y response en el evento para obtener más información sobre el destinatario de la notificación o la notificación en sí:

/**
 * Handle the event.
 */
public function handle(NotificationSent $event): void
{
    // $event->channel
    // $event->notifiable
    // $event->notification
    // $event->response
}

Canales personalizados

Laravel se envía con unos pocos canales de notificación, pero es posible que desee escribir sus propios controladores para enviar notificaciones a través de otros canales. Laravel lo hace simple. Para empezar, defina una clase que contenga un método send. El método debe recibir dos argumentos: un $notifiable y un $notification.

Dentro del método send, puede llamar a métodos en la notificación para recuperar un objeto de mensaje entendido por su canal y luego enviar la notificación a la instancia $notifiable como desee:

<?php
 
namespace App\Notifications;
 
use Illuminate\Notifications\Notification;
 
class VoiceChannel
{
    /**
     * Enviar la notificación dada.
     */
    public function send(object $notifiable, Notification $notification): void
    {
        $message = $notification->toVoice($notifiable);
 
        // Enviar notificación al objeto $notifiable...
    }
}

Una vez que se haya definido la clase de canal de notificación, puede devolver el nombre de la clase desde el método via de cualquiera de sus notificaciones. En este ejemplo, el método toVoice de su notificación puede devolver cualquier objeto que elija para representar mensajes de voz. Por ejemplo, podría definir su propia clase VoiceMessage para representar estos mensajes:

<?php
 
namespace App\Notifications;
 
use App\Notifications\Messages\VoiceMessage;
use App\Notifications\VoiceChannel;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
 
class InvoicePaid extends Notification
{
    use Queueable;
 
    /**
     * Obtener los canales de la notificación.
     */
    public function via(object $notifiable): string
    {
        return VoiceChannel::class;
    }
 
    /**
     * Obtener la representación de voz de la notificación.
     */
    public function toVoice(object $notifiable): VoiceMessage
    {
        // ...
    }
}

Introducción

Generación de notificaciones

Envío de notificaciones

Uso del rasgo Notifiable

Uso del Facade de notificación

Especificación de canales de entrega

Cola de notificaciones

Retraso de notificaciones

Retraso de notificaciones por canal

Personalización de la conexión de la cola de notificaciones

Personalización de colas de canales de notificación

Notificaciones en cola y transacciones de base de datos

Determinar si debe enviarse una notificación en cola

Notificaciones a petición

Notificaciones por correo electrónico

Formato de mensajes de correo

Mensajes de error

Otras opciones de formato de notificaciones por correo

Personalización del remitente

Personalización del destinatario

Personalización del asunto

Personalización del remitente de correo

Personalización de las plantillas

Adjuntos

Adjuntos de datos sin procesar

Agregar etiquetas y metadatos

Personalización del mensaje Symfony

Uso de Mailables

Mailables y notificaciones a petición

Vista previa de notificaciones por correo

Notificaciones por correo con formato Markdown

Generación del mensaje

Escritura del mensaje

Componente de botón

Componente de panel

Componente de tabla

Personalización de los componentes

Personalización del CSS

Notificaciones por base de datos

Prerrequisitos

Formato de notificaciones por base de datos

toDatabase Vs. toArray

Acceso a las notificaciones

Marcar notificaciones como leídas

Notificaciones por transmisión

Prerrequisitos

Formato de notificaciones por transmisión

Configuración de la cola de transmisión

Personalización del tipo de notificación

Escucha de notificaciones

Personalización del canal de notificación

Notificaciones por SMS

Prerrequisitos

Formato de notificaciones por SMS

Contenido Unicode

Personalización del número "De"

Agregar una referencia de cliente

Enrutamiento de notificaciones por SMS

Notificaciones por Slack

Prerrequisitos

Distribución de la aplicación

Formato de notificaciones por Slack

Interactividad de Slack

Modales de confirmación

Inspección de bloques de Slack

Enrutamiento de notificaciones por Slack

Notificación a espacios de trabajo de Slack externos

Localización de notificaciones

Idiomas preferidos por el usuario

Pruebas

Notificaciones a petición

Eventos de notificaciones

Evento de envío de notificaciones

Evento de notificación enviada

Canales personalizados

📘 Sección de artículos sobre Laravel: próximamente

`toDatabase` Vs. `toArray`