Notificaciones

Introducción
Generación de Notificaciones
Envío de Notificaciones
Notificaciones por Correo
Notificaciones Markdown por Correo
Notificaciones en Base de Datos
Notificaciones Broadcast
Notificaciones SMS
Notificaciones Slack
Localización de Notificaciones
Pruebas
Eventos de Notificación
Canales Personalizados

#Introducción

Además del soporte para envío de correo, Laravel ofrece soporte para enviar notificaciones a través de diversos canales de entrega, incluyendo correo electrónico, SMS (a través de Vonage, anteriormente conocido como Nexmo) y Slack. Además, se han creado numerosos canales de notificación comunitarios para enviar notificaciones por decenas de canales diferentes. Las notificaciones también pueden almacenarse en una base de datos para mostrarse en su interfaz web.

Normalmente, las notificaciones deben ser mensajes breves e informativos que alerten a los usuarios sobre algo que ocurrió en su aplicación. Por ejemplo, si está desarrollando una aplicación de facturación, podría enviar una notificación "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 clase única que normalmente se almacena en el directorio app/Notifications. No se preocupe si no ve este directorio en su aplicación: se creará automáticamente 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 para construir 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 Trait Notifiable

Las notificaciones pueden enviarse de dos maneras: usando el método notify del trait Notifiable o usando el facade Notification. El trait Notifiable está incluido por defecto en el modelo App\Models\User de su aplicación:

<?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 que proporciona este trait espera recibir una instancia de notificación:

use App\Notifications\InvoicePaid;

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

Примечание

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

#Uso del Facade Notification

Alternativamente, puede enviar notificaciones a través del facade Notification. Este enfoque es útil cuando necesita enviar una notificación a múltiples entidades notificables, como una colección de usuarios. Para enviar notificaciones usando 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 usando el método sendNow. Este método enviará la notificación de inmediato incluso si la notificación implementa la interfaz ShouldQueue:

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

#Especificar 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 pueden enviarse por los canales mail, database, broadcast, vonage y slack.

Примечание

Si desea usar otros canales de entrega como Telegram o Pusher, consulte el sitio web comunitario Laravel Notification Channels.

El método via recibe una instancia $notifiable, que será una instancia de la clase a la que se envía 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

Внимание

Antes de poner notificaciones en cola, debe configurar su cola y iniciar un worker.

El envío de notificaciones puede tomar tiempo, especialmente si el canal necesita hacer una llamada a una API externa para entregar la notificación. Para acelerar el tiempo de respuesta de su aplicación, permita que su notificación se ponga en cola agregando la interfaz ShouldQueue y el trait Queueable a su clase. La interfaz y el trait ya están importados para todas las notificaciones generadas con el comando make:notification, por lo que puede agregarlos inmediatamente 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 la interfaz ShouldQueue ha sido añadida a su notificación, puede enviar la notificación normalmente. Laravel detectará la interfaz ShouldQueue en la clase y pondrá automáticamente en cola la entrega de la notificación:

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

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

#Retrasar Notificaciones

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

$delay = now()->addMinutes(10);

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

#Retrasar Notificaciones por Canal

Puede pasar un arreglo al método delay para especificar el tiempo de retraso 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 clase de notificación. El método withDelay debe devolver un arreglo con los nombres de los canales y los 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),
    ];
}

#Personalizar la Conexión de la Cola de Notificaciones

Por defecto, las notificaciones en cola se pondrán en la cola usando la conexión de cola predeterminada de su aplicación. Si desea especificar una conexión diferente 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 soportado por la notificación, puede definir un método viaConnections en su notificación. Este método debe devolver un arreglo con pares de nombre de canal / nombre de conexión de cola:

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

#Personalizar las Colas de los Canales de Notificación

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

/**
 * Determinar qué colas se deben usar 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 ser procesadas por la cola antes de que la transacción de base de datos se haya confirmado. Cuando esto sucede, cualquier actualización que haya hecho a modelos o registros de base de datos durante la transacción puede que aún no se refleje en la base de datos. Además, cualquier modelo o registro creado dentro de la transacción puede que no exista aún en la base de datos. Si su notificación depende de estos modelos, pueden ocurrir errores inesperados cuando se procese 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á establecida en false, aún puede indicar que una notificación en cola particular debe despacharse después de que todas las transacciones abiertas de base de datos hayan sido confirmadas 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();
    }
}

Примечание

Para aprender más sobre cómo manejar estos problemas, por favor revise la documentación sobre trabajos en cola y transacciones de base de datos.

#Determinar si una Notificación en Cola Debe Ser Enviada

Después de que una notificación en cola ha sido despachada para procesamiento en segundo plano, normalmente será aceptada por un worker de la cola y enviada a su destinatario previsto.

Sin embargo, si desea tomar la decisión final sobre si la notificación en cola debe enviarse después de que está siendo procesada por un worker, puede definir un método shouldSend en la clase de notificación. Si este método devuelve false, la notificación no será enviada:

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

#Notificaciones Bajo Demanda

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

use Illuminate\Broadcasting\Channel;
use Illuminate\Support\Facades\Notification;

Notification::route('mail', 'taylor@example.com')
            ->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 pasar un arreglo que contenga la dirección de correo como clave y el nombre como valor del primer elemento del arreglo:

Notification::route('mail', [
    'barrett@example.com' => 'Barrett Blair',
])->notify(new InvoicePaid($invoice));

Usando el método routes, puede proporcionar información de enrutamiento ad-hoc para múltiples canales de notificación a la vez:

Notification::routes([
    'mail' => ['barrett@example.com' => 'Barrett Blair'],
    'vonage' => '5555555555',
])->notify(new InvoicePaid($invoice));

#Notificaciones por Correo

#Formato de Mensajes de Correo

Si una notificación soporta 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 ayudarle a construir mensajes de correo transaccionales. Los mensajes de correo pueden contener líneas de texto así como un "llamado a la acción". Veamos un ejemplo del método toMail:

/**
 * Obtener la representación en correo 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!');
}

Примечание

Note que estamos usando $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 correos transaccionales pequeños. El canal de correo luego traducirá los componentes del mensaje en una hermosa plantilla HTML responsiva con una contraparte en texto plano. Aquí hay un ejemplo de un correo generado por el canal mail:

Примечание

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

#Mensajes de Error

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

/**
 * Obtener la representación en correo de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->error()
                ->subject('Pago de Factura Fallido')
                ->line('...');
}

#Otras Opciones de Formato para 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 usará para renderizar el correo de la notificación:

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

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

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

O, si su mensaje solo tiene una vista en texto plano, puede usar el método text:

/**
 * Obtener la representación en correo de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)->text(
        'mail.invoice.paid-text', ['invoice' => $this->invoice]
    );
}

#Personalización del Remitente

Por defecto, la dirección del remitente / from del correo está definida en el archivo de configuración config/mail.php. Sin embargo, puede especificar la dirección from para una notificación específica usando el método from:

/**
 * Obtener la representación en correo de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->from('barrett@example.com', 'Barrett Blair')
                ->line('...');
}

#Personalización del Destinatario

Al enviar notificaciones a través del canal mail, el sistema de notificaciones buscará automáticamente una propiedad email en su entidad notificable. Puede personalizar qué dirección de correo se usa 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 mail.
     *
     * @return  array<string, string>|string
     */
    public function routeNotificationForMail(Notification $notification): array|string
    {
        // Retornar solo la dirección de correo...
        return $this->email_address;

        // Retornar dirección de correo y nombre...
        return [$this->email_address => $this->name];
    }
}

#Personalización del Asunto

Por defecto, el asunto del correo es el nombre de la clase de la notificación formateado en "Title Case". Por ejemplo, si su clase de notificación se llama InvoicePaid, el asunto del correo 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 en correo de la notificación.
 */
public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
                ->subject('Asunto de la Notificación')
                ->line('...');
}

#Personalización del Mailer

Por defecto, la notificación por correo se enviará usando el mailer predeterminado definido en el archivo de configuración config/mail.php. Sin embargo, puede especificar un mailer diferente en tiempo de ejecución llamando al método mailer al construir su mensaje:

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

#Personalización de Plantillas

Puede modificar las plantillas HTML y de texto plano usadas por las notificaciones por correo publicando los recursos del paquete de notificaciones. Después de ejecutar este comando, las plantillas de notificación por correo estarán ubicadas en el directorio resources/views/vendor/notifications:

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

#Archivos Adjuntos

Para agregar archivos adjuntos a una notificación por correo, use el método attach mientras construye su mensaje. El método attach acepta la ruta absoluta al archivo como su primer argumento:

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

Примечание

El método attach ofrecido por los mensajes de correo de notificación también acepta objetos adjuntables. Por favor, consulte la documentación completa sobre objetos adjuntables para aprender más.

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

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

A diferencia de adjuntar archivos en objetos mailable, no puede adjuntar un archivo directamente desde un disco de almacenamiento usando attachFromStorage. En su lugar, debe usar el método attach con una ruta absoluta al 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 en correo 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 múltiples archivos a un mensaje usando el método attachMany:

/**
 * Obtener la representación por correo 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 con datos en bruto

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

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

#Añadiendo etiquetas y metadatos

Algunos proveedores de correo electrónico de terceros como Mailgun y Postmark soportan "etiquetas" y "metadatos" en los mensajes, que pueden usarse para agrupar y rastrear los correos enviados por su aplicación. Puede añadir etiquetas y metadatos a un mensaje de correo mediante los métodos tag y metadata:

/**
 * Obtener la representación por correo 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 usa el driver Mailgun, puede consultar la documentación de Mailgun para más información sobre etiquetas y metadatos. De igual forma, la documentación de Postmark también puede consultarse para más información sobre su soporte para etiquetas y metadatos.

Si su aplicación usa Amazon SES para enviar correos, debe usar el método metadata para adjuntar etiquetas SES ("tags") al mensaje.

#Personalizando el mensaje de Symfony

El método withSymfonyMessage de la clase MailMessage le permite registrar un closure que será invocado con la instancia del mensaje Symfony antes de enviar el mensaje. Esto le da la oportunidad de personalizar profundamente el mensaje antes de que sea entregado:

use Symfony\Component\Mime\Email;

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

#Usando Mailables

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

use App\Mail\InvoicePaid as InvoicePaidMailable;
use Illuminate\Mail\Mailable;

/**
 * Obtener la representación por correo de la notificación.
 */
public function toMail(object $notifiable): Mailable
{
    return (new InvoicePaidMailable($this->invoice))
                ->to($notifiable->email);
}

#Mailables y notificaciones bajo demanda

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 puede usarse para obtener la dirección de correo a la que debe enviarse la notificación bajo demanda:

use App\Mail\InvoicePaid as InvoicePaidMailable;
use Illuminate\Notifications\AnonymousNotifiable;
use Illuminate\Mail\Mailable;

/**
 * Obtener la representación por correo 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);
}

#Previsualizando notificaciones por correo

Al diseñar una plantilla de notificación por correo, es conveniente previsualizar rápidamente el mensaje renderizado en el navegador como una plantilla Blade típica. Por esta razón, Laravel permite devolver cualquier mensaje de correo generado por una notificación directamente desde un closure de ruta o un controlador. Cuando se devuelve un MailMessage, este se renderiza y muestra en el navegador, permitiéndole previsualizar su diseño sin necesidad de enviarlo a una dirección de correo 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 Markdown

Las notificaciones por correo Markdown le permiten aprovechar las plantillas preconstruidas de las notificaciones por correo, mientras le dan más libertad para escribir mensajes más largos y personalizados. Dado que los mensajes se escriben en Markdown, Laravel puede renderizar hermosas plantillas HTML responsivas para los mensajes y también generar automáticamente una versión en texto plano.

#Generando el mensaje

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

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

Como todas las demás notificaciones por correo, las notificaciones que usan plantillas 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 Markdown que debe usarse. 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 por correo 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]);
}

#Escribiendo el mensaje

Las notificaciones por correo Markdown usan una combinación de componentes Blade y sintaxis Markdown que le permiten construir notificaciones fácilmente mientras aprovecha los componentes predefinidos de notificación 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 botón

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

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

#Componente panel

El componente 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 específico:

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

#Componente tabla

El componente tabla le permite transformar una tabla Markdown en una tabla HTML. El componente acepta la tabla Markdown como su contenido. Se soporta la alineación de columnas usando la sintaxis de alineación por defecto de las tablas Markdown:

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

#Personalizando los componentes

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

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

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

#Personalizando el 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 serán automáticamente insertados en línea dentro de las representaciones HTML de sus notificaciones Markdown.

Si desea construir un tema completamente nuevo para los componentes 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 de una notificación individual, puede llamar al método theme mientras construye el mensaje de correo de la notificación. El método theme acepta el nombre del tema que debe usarse al enviar la notificación:

/**
 * Obtener la representación por correo 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 en base de datos

#Requisitos previos

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, necesitará crear una tabla en la base de datos para almacenar sus notificaciones. Puede usar el comando notifications:table para generar una migración con el esquema de tabla adecuado:

php artisan notifications:table

php artisan migrate

Примечание

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

#Formateando notificaciones en base de datos

Si una notificación soporta 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 plano. El array devuelto será codificado como JSON y almacenado en la columna data de su tabla notifications. Veamos un ejemplo del método toArray:

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

Cuando la notificación se almacena en la base de datos de su aplicación, la columna type se llenará con el nombre de la clase de la notificación. Sin embargo, puede personalizar este comportamiento definiendo un método databaseType en su clase de notificación:

/**
 * Obtener el tipo de la notificación para la base de datos.
 *
 * @return string
 */
public function databaseType(object $notifiable): string
{
    return 'invoice-paid';
}

#`toDatabase` vs. `toArray`

El método toArray también es usado por el canal broadcast para determinar qué datos transmitir a su frontend basado en JavaScript. Si desea tener dos representaciones en array diferentes para los canales database y broadcast, debe definir un método toDatabase en lugar de toArray.

#Accediendo a las notificaciones

Una vez que las notificaciones están almacenadas en la base de datos, necesita una forma conveniente de acceder a ellas desde sus entidades notifiables. El trait Illuminate\Notifications\Notifiable, que está incluido en el modelo App\Models\User por defecto de Laravel, incluye una relación Eloquent llamada notifications que devuelve las notificaciones para la entidad. Para obtener las 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 inicio 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 más recientes al inicio de la colección:

$user = App\Models\User::find(1);

foreach ($user->unreadNotifications as $notification) {
    echo $notification->type;
}

Примечание

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 notifiable, como el usuario actual. Luego puede hacer una solicitud HTTP a la URL de ese controlador desde su cliente JavaScript.

#Marcando notificaciones como leídas

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

$user = App\Models\User::find(1);

foreach ($user->unreadNotifications as $notification) {
    $notification->markAsRead();
}

Sin embargo, en lugar de iterar sobre 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 Broadcast

#Requisitos previos

Antes de transmitir notificaciones, debe configurar y estar familiarizado con los servicios de event broadcasting de Laravel. El event broadcasting proporciona una forma de reaccionar a eventos del lado servidor de Laravel desde su frontend basado en JavaScript.

#Formateando notificaciones Broadcast

El canal broadcast transmite notificaciones usando los servicios de event broadcasting de Laravel, permitiendo que su frontend basado en JavaScript reciba notificaciones en tiempo real. Si una notificación soporta broadcasting, 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 usará el método toArray para obtener los datos que deben transmitirse. Los datos devueltos serán codificados como JSON y transmitidos a su frontend basado en JavaScript. Veamos un ejemplo del método toBroadcast:

use Illuminate\Notifications\Messages\BroadcastMessage;

/**
 * Obtener la representación transmitible 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 Broadcast

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

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

#Personalizando el tipo de notificación

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

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

#Escuchando notificaciones

Las notificaciones se transmitirán en un canal privado formateado usando la convención {notifiable}.{id}. Por ejemplo, si envía una notificación a una instancia App\Models\User con ID 1, la notificación se transmitirá en el canal privado App.Models.User.1. Al usar Laravel Echo, puede escuchar fácilmente notificaciones en un canal usando el método notification:

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

#Personalizando el canal de notificación

Si desea personalizar en qué canal se transmiten las notificaciones broadcast de una entidad, puede definir un método receivesBroadcastNotificationsOn en la entidad notifiable:

<?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
    {
        return 'users.'.$this->id;
    }
}

#Notificaciones SMS

#Requisitos previos

El envío de notificaciones SMS en Laravel está potenciado por Vonage (anteriormente conocido como Nexmo). Antes de poder enviar notificaciones vía 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ública y secreta de Vonage.

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

VONAGE_SMS_FROM=15556666666

#Formateando notificaciones SMS

Si una notificación soporta 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 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 VonageMessage:

use Illuminate\Notifications\Messages\VonageMessage;

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

#Personalizando el número "Desde"

Si desea enviar algunas notificaciones desde un número de teléfono diferente al 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 Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->content('Your SMS message content')
                ->from('15554443333');
}

#Añadiendo una referencia de cliente

Si desea llevar un control de costos por usuario, equipo o cliente, puede añadir una "referencia de cliente" a la notificación. Vonage le permitirá generar reportes usando esta referencia para que pueda entender 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 Vonage / SMS de la notificación.
 */
public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->clientReference((string) $notifiable->id)
                ->content('Your SMS message content');
}

#Enrutando notificaciones SMS

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

<?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 Slack

#Requisitos previos

Antes de enviar notificaciones Slack, debe instalar el canal de notificaciones Slack vía Composer:

composer require laravel/slack-notification-channel

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

Si solo necesita enviar notificaciones al mismo espacio de trabajo Slack donde se creó la App, debe asegurarse de que su App tenga los scopes chat:write, chat:write.public y chat:write.customize. Estos scopes pueden añadirse desde la pestaña "OAuth & Permissions" en la gestión de la App dentro de Slack.

Luego, copie el "Bot User OAuth Token" de la App 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 encuentra 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 App

Si su aplicación enviará notificaciones a espacios de trabajo Slack externos que son propiedad de los usuarios de su aplicación, necesitará "distribuir" su App vía Slack. La distribución de la App puede gestionarse desde la pestaña "Manage Distribution" de su App dentro de Slack. Una vez que su App esté distribuida, puede usar Socialite para obtener tokens de Slack Bot en nombre de los usuarios de su aplicación.

#Formateando notificaciones Slack

Si una notificación admite enviarse como un mensaje de Slack, debe definir un método toSlack en la clase de la notificación. Este método recibirá una entidad $notifiable y debe devolver una instancia de Illuminate\Notifications\Slack\SlackMessage. Puede construir notificaciones enriquecidas usando la API Block Kit de Slack. El siguiente ejemplo puede previsualizarse en el constructor Block Kit de Slack:

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 Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('¡Una de sus facturas ha sido pagada!')
            ->headerBlock('Factura Pagada')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Cliente #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('Se ha pagado una factura.');
                $block->field("*No. de Factura:*\n1000")->markdown();
                $block->field("*Destinatario de la Factura:*\ntaylor@laravel.com")->markdown();
            })
            ->dividerBlock()
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('¡Felicidades!');
            });
}

#Interactividad en Slack

El sistema de notificaciones Block Kit de Slack ofrece 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 administrar desde la pestaña "Interactividad y Atajos" en la gestión de la aplicación dentro de Slack.

En el siguiente ejemplo, que utiliza el método actionsBlock, Slack enviará una solicitud POST a su "URL de solicitud" con una carga útil que contiene el usuario de Slack que hizo clic en el botón, el ID del botón pulsado y más. Su aplicación podrá entonces determinar la acción a tomar según la carga útil. También debe verificar que 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 Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('¡Una de sus facturas ha sido pagada!')
            ->headerBlock('Factura Pagada')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Cliente #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('Se ha pagado una factura.');
            })
            ->actionsBlock(function (ActionsBlock $block) {
                 // El ID por defecto es "button_acknowledge_invoice"...
                $block->button('Reconocer Factura')->primary();

                // Configurar manualmente el ID...
                $block->button('Denegar')->danger()->id('deny_invoice');
            });
}

#Modales de Confirmación

Si desea que los usuarios confirmen una acción antes de que se ejecute, puede invocar el método confirm al definir su botón. El método confirm acepta un mensaje y un closure 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 Slack de la notificación.
 */
public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('¡Una de sus facturas ha sido pagada!')
            ->headerBlock('Factura Pagada')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Cliente #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('Se ha pagado una factura.');
            })
            ->actionsBlock(function (ActionsBlock $block) {
                $block->button('Reconocer Factura')
                    ->primary()
                    ->confirm(
                        '¿Reconocer el pago y enviar un correo de agradecimiento?',
                        function (ConfirmObject $dialog) {
                            $dialog->confirm('Sí');
                            $dialog->deny('No');
                        }
                    );
            });
}

#Inspeccionando 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 mostrará una URL al Block Kit Builder de Slack, que muestra una vista previa de la carga útil y la notificación en su navegador. Puede pasar true al método dd para mostrar la carga útil sin procesar:

return (new SlackMessage)
        ->text('¡Una de sus facturas ha sido pagada!')
        ->headerBlock('Factura Pagada')
        ->dd();

#Enrutando Notificaciones de Slack

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

null - lo que delega el enrutamiento al canal configurado en la propia notificación. 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 enviar la notificación, por ejemplo, #support-channel.
Una instancia de SlackRoute, que le permite especificar un token OAuth y el nombre del 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 OAuth de usuario 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 de Slack.
     */
    public function routeNotificationForSlack(Notification $notification): mixed
    {
        return '#support-channel';
    }
}

#Notificando Espacios de Trabajo Externos de Slack

Примечание

Antes de enviar notificaciones a espacios de trabajo externos de Slack, 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 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, probablemente su aplicación necesitará ofrecer una opción para que el usuario especifique a qué canal deben enviarse 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 de 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 un idioma distinto al locale actual de la solicitud HTTP, e incluso recordará este locale 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 este locale cuando se evalúe la notificación y luego volverá al locale anterior cuando termine la evaluación:

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

La localización de múltiples entradas notifiables también puede lograrse mediante el facade Notification:

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

#Locales Preferidos por el Usuario

A veces, las aplicaciones almacenan el locale preferido de cada usuario. Al implementar el contrato HasLocalePreference en su modelo notifiable, puede indicar a Laravel que use este locale almacenado al enviar una notificación:

use Illuminate\Contracts\Translation\HasLocalePreference;

class User extends Model implements HasLocalePreference
{
    /**
     * Obtener el locale preferido del usuario.
     */
    public function preferredLocale(): string
    {
        return $this->locale;
    }
}

Una vez que haya implementado la interfaz, Laravel usará automáticamente el locale preferido al enviar notificaciones y mailables al modelo. Por lo tanto, no es necesario llamar al método locale cuando use esta interfaz:

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

#Pruebas

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

Después de llamar al método fake del facade Notification, puede afirmar que se instruyó el envío de notificaciones a 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...

        // Afirmar que no se enviaron notificaciones...
        Notification::assertNothingSent();

        // Afirmar que se envió una notificación a los usuarios dados...
        Notification::assertSentTo(
            [$user], OrderShipped::class
        );

        // Afirmar que no se envió una notificación...
        Notification::assertNotSentTo(
            [$user], AnotherNotification::class
        );

        // Afirmar que se enviaron un número dado de notificaciones...
        Notification::assertCount(3);
    }
}

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

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

#Notificaciones Bajo Demanda

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

Notification::assertSentOnDemand(OrderShipped::class);

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

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

#Eventos de Notificación

#Evento de Envío de Notificación

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

use App\Listeners\CheckNotificationStatus;
use Illuminate\Notifications\Events\NotificationSending;

/**
 * Mapeo de escuchas de eventos para la aplicación.
 *
 * @var array
 */
protected $listen = [
    NotificationSending::class => [
        CheckNotificationStatus::class,
    ],
];

La notificación no se enviará si un escucha del evento NotificationSending devuelve false desde su método handle:

use Illuminate\Notifications\Events\NotificationSending;

/**
 * Manejar el evento.
 */
public function handle(NotificationSending $event): bool
{
    return false;
}

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

/**
 * Manejar el evento.
 */
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 sistema de notificaciones despacha el evento Illuminate\Notifications\Events\NotificationSent. Este contiene la entidad "notifiable" y la instancia de la notificación. Puede registrar escuchas para este evento en su EventServiceProvider:

use App\Listeners\LogNotification;
use Illuminate\Notifications\Events\NotificationSent;

/**
 * Mapeo de escuchas de eventos para la aplicación.
 *
 * @var array
 */
protected $listen = [
    NotificationSent::class => [
        LogNotification::class,
    ],
];

Примечание

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

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

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

#Canales Personalizados

Laravel incluye varios canales de notificación, pero puede que desee escribir sus propios drivers para entregar notificaciones a través de otros canales. Laravel lo hace sencillo. Para comenzar, defina una clase que contenga un método send. El método debe recibir dos argumentos: un $notifiable y una $notification.

Dentro del método send, puede llamar a métodos en la notificación para obtener 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 a la instancia $notifiable...
    }
}

Una vez que su clase de canal de notificación esté definida, 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 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 Trait Notifiable

#Uso del Facade Notification

#Especificar Canales de Entrega

#Cola de Notificaciones

#Retrasar Notificaciones

#Retrasar Notificaciones por Canal

#Personalizar la Conexión de la Cola de Notificaciones

#Personalizar las Colas de los Canales de Notificación

#Notificaciones en Cola y Transacciones de Base de Datos

#Determinar si una Notificación en Cola Debe Ser Enviada

#Notificaciones Bajo Demanda

#Notificaciones por Correo

#Formato de Mensajes de Correo

#Mensajes de Error

#Otras Opciones de Formato para Notificaciones por Correo

#Personalización del Remitente

#Personalización del Destinatario

#Personalización del Asunto

#Personalización del Mailer

#Personalización de Plantillas

#Archivos Adjuntos

#Adjuntos con datos en bruto

#Añadiendo etiquetas y metadatos

#Personalizando el mensaje de Symfony

#Usando Mailables

#Mailables y notificaciones bajo demanda

#Previsualizando notificaciones por correo

#Notificaciones por correo Markdown

#Generando el mensaje

#Escribiendo el mensaje

#Componente botón

#Componente panel

#Componente tabla

#Personalizando los componentes

#Personalizando el CSS

#Notificaciones en base de datos

#Requisitos previos

#Formateando notificaciones en base de datos

#toDatabase vs. toArray

#Accediendo a las notificaciones

#Marcando notificaciones como leídas

#Notificaciones Broadcast

#Requisitos previos

#Formateando notificaciones Broadcast

#Configuración de la cola de Broadcast

#Personalizando el tipo de notificación

#Escuchando notificaciones

#Personalizando el canal de notificación

#Notificaciones SMS

#Requisitos previos

#Formateando notificaciones SMS

#Contenido Unicode

#Personalizando el número "Desde"

#Añadiendo una referencia de cliente

#Enrutando notificaciones SMS

#Notificaciones Slack

#Requisitos previos

#Distribución de la App

#Formateando notificaciones Slack

#Interactividad en Slack

#Modales de Confirmación

#Inspeccionando Bloques de Slack

#Enrutando Notificaciones de Slack

#Notificando Espacios de Trabajo Externos de Slack

#Localización de Notificaciones

#Locales Preferidos por el Usuario

#Pruebas

#Notificaciones Bajo Demanda

#Eventos de Notificación

#Evento de Envío de Notificación

#Evento de Notificación Enviada

#Canales Personalizados

#`toDatabase` vs. `toArray`