{Hinweis:} Stellen Sie beim Senden einer E-Mail-Benachrichtigung sicher, dass der Wert von config/app.php in der Konfigurationsdatei name festgelegt ist. Dieser Wert wird in der E-Mail verwendet Benachrichtigungsmeldung.

Weitere Formatierungsoptionen für Benachrichtigungen

Zusätzlich zum Definieren von mehrzeiligem Text in der Benachrichtigungsklasse können Sie auch die Methode view verwenden, um eine benutzerdefinierte Vorlage zum Rendern anzugeben Benachrichtigungs-E-Mails:

/**
 * 获取通知邮件。
 *
 * @param  mixed  $notifiable
 * @return \Illuminate\Notifications\Messages\MailMessage
 */
 public function toMail($notifiable){
     return (new MailMessage)->view(  
           'emails.name', ['invoice' => $this->invoice]  
          );
    }

Darüber hinaus können Sie ein versandfähiges Objekt von der Methode toMail zurückgeben :

use App\Mail\InvoicePaid as Mailable;
/**
 * Get the mail representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return Mailable
 */
 public function toMail($notifiable){ 
    return (new Mailable($this->invoice))->to($this->user->email);
  }

Fehlermeldung

Einige Benachrichtigungen informieren Benutzer über Fehlermeldungen, wie z. B. eine fehlgeschlagene Bestellungszahlung. Sie können beim Erstellen der Nachricht die Methode error aufrufen, um anzugeben, dass es sich bei der E-Mail-Nachricht um eine Fehlermeldung handelt. Wenn Sie die error-Methode in einer E-Mail-Nachricht verwenden, wird die Aktionsschaltfläche rot:

/**
 * 获取通知邮件。
 *
 * @param  mixed  $notifiable
 * @return \Illuminate\Notifications\Message
 */
 public function toMail($notifiable){
     return (new MailMessage)            
         ->error()                
         ->subject('Notification Subject')                
         ->line('...');
      }

Benutzerdefinierte Empfänger

Passmail Wenn der Kanal eine Benachrichtigung sendet, sucht das Benachrichtigungssystem automatisch nach dem Attribut email für die benachrichtigte Entität. Sie können ein definieren routeNotificationForMail Passen Sie an, welche E-Mail-Adresse zum Senden von Benachrichtigungen verwendet werden soll:

<?php
    namespace App;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{
        use Notifiable;    
     /**
     * 邮件通道通知的路由。
     *
     * @param  \Illuminate\Notifications\Notification  $notification
     * @return string
     */   
   public function routeNotificationForMail($notification) 
      {     
         return $this->email_address;   
      }
  }

Betreff anpassen

Standardmäßig lautet der Betreff der E-Mail im Format „Titelstil“ Name der Benachrichtigungsklasse. Wenn die Benachrichtigungsklasse also InvoicePaid heißt, lautet der Betreff der E-Mail Invoice Paid, wenn Sie ein klares Thema für die Nachricht angeben möchten, können Sie beim Erstellen der Nachricht die Methode subject aufrufen:

/**
 * 获取通知的邮件表示。
 *
 * @param  mixed  $notifiable
 * @return \Illuminate\Notifications\Messages\MailMessage
 */
 public function toMail($notifiable){ 
    return (new MailMessage)              
      ->subject('Notification Subject')                
      ->line('...');
  }

Benutzerdefinierte Vorlage

Sie können die von E-Mail-Benachrichtigungen verwendeten HTML- und Nur-Text-Vorlagen ändern, indem Sie die Ressourcen des Benachrichtigungserweiterungspakets veröffentlichen. Nach Ausführung des folgenden Befehls wird die E-Mail-Benachrichtigungsvorlage im Verzeichnis resources/views/vendor/notifications gespeichert:

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

Markdown-E-Mail-Benachrichtigung

Markdown-E-Mail Benachrichtigung Ermöglicht Ihnen die Nutzung vorgefertigter Vorlagen für E-Mail-Benachrichtigungen und gibt Ihnen die Freiheit, längere, personalisiertere Nachrichten zu schreiben. Da diese Nachrichten im Markdown-Format geschrieben sind, kann Laravel sie auch in schöne, reaktionsfähige HTML-Vorlagen rendern und gleichzeitig automatisch reine Textkopien erstellen.

Nachricht generieren

Um eine Benachrichtigung mit der entsprechenden Markdown-Vorlage zu generieren, können Sie den Artisan-Befehl make:notification mit --markdown Optionen verwenden :

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

Verwenden Sie wie andere E-Mail-Benachrichtigungen Markdown Die Benachrichtigungsklasse der Vorlage muss außerdem eine toMail-Methode definieren. Sie können jedoch die Methode markdown anstelle der Methoden line und action des Konstruktors verwenden, um den Namen der zu verwendenden Markdown-Vorlage anzugeben:

/**
 * 获取通知的邮件表示。
 *
 * @param  mixed  $notifiable
 * @return \Illuminate\Notifications\Messages\MailMessage
 */
 public function toMail($notifiable){ 
    $url = url('/invoice/'.$this->invoice->id);    
    return (new MailMessage)              
      ->subject('Invoice Paid')                
      ->markdown('mail.invoice.paid', ['url' => $url]);
   }

Eine Nachricht schreiben

Markdown-E-Mail-Benachrichtigung verwendet Blade-Komponenten und Markdown-Syntax, sodass Sie ganz einfach Benachrichtigungen erstellen können, ohne sich von den vorgefertigten Komponenten von Laravel zu trennen:

@component('mail::message')
# Invoice PaidYour invoice has been paid!
@component('mail::button', ['url' => $url])
View Invoice
@endcomponent
Thanks,<br>
{{ config('app.name') }}
@endcomponent

Button-Komponente

Die Schaltflächenkomponente rendert einen zentrierten Schaltflächenlink. Diese Komponente erhält zwei Parameter, url und optional color. Die unterstützten Farben sind blue, green und red. Sie können der Nachricht beliebig viele Schaltflächenkomponenten hinzufügen:

@component('mail::button', ['url' => $url, 'color' => 'green'])
View Invoice
@endcomponent

Panel-Komponente

Panel-Komponente stellt den angegebenen Textblock in einem Panel mit heller Hintergrundfarbe dar und umliegende Nachrichten werden hervorgehoben. Ideal für Textblöcke, die Aufmerksamkeit erfordern:

@component('mail::panel')
This is the panel content.
@endcomponent

Tabellenkomponente

Mit der Tabellenkomponente können Sie eine Markdown-Tabelle in eine HTML-Tabelle konvertieren. Als Inhalt erhält diese Komponente eine Markdown-Tabelle. Die Tabellenspaltenausrichtung unterstützt die Verwendung der standardmäßigen Markdown-Tabellenspaltenausrichtungssyntax:

@component('mail::table')
| Laravel       | Table         | Example  |
| ------------- |:-------------:| --------:|
| Col 2 is      | Centered      |       |
| Col 3 is      | Right-Aligned |       |
@endcomponent

Benutzerdefinierte Komponente

Sie können alle Markdown-Benachrichtigungskomponenten in die Anwendung exportieren Um Komponenten anzupassen und zu exportieren, verwenden Sie den Artisan-Befehl vendor:publish, um laravel-mail zu veröffentlichen Ressourcen-Tag:

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

Dieser Befehl veröffentlicht die Markdown-E-Mail-Benachrichtigungskomponente im Verzeichnis resources/views/vendor/mail. Das Verzeichnis mail enthält die Verzeichnisse html und markdown, von denen jedes alle seine gültigen Komponenten enthält. Es steht Ihnen frei, diese Komponenten nach Ihren Wünschen zu bearbeiten.

Benutzerdefiniertes CSS

Nach dem Exportieren der Komponente enthält das Verzeichnis resources/views/vendor/mail/html/themes eine Standarddatei default.css. Sie können das CSS in dieser Datei anpassen, um den HTML-Stil der Markdown-Benachrichtigung anzupassen wird automatisch angepasst.

{Hinweis:} Wenn Sie ein brandneues Theme für Markdown-Komponenten erstellen möchten, schreiben Sie einfach eine neue CSS-Datei in das Verzeichnis html/themes und ändern Sie die Option mail der theme-Konfigurationsdatei .

Datenbankbenachrichtigung

Vorkenntnisse

database Benachrichtigungskanäle speichern Benachrichtigungsinformationen in einer Datentabelle, die Informationen wie den Benachrichtigungstyp und benutzerdefinierte JSON-Daten zur Beschreibung der Benachrichtigung enthält.

Sie können diese Datentabelle in der Benutzeroberfläche abfragen, um Benachrichtigungen anzuzeigen. Zuvor müssen Sie jedoch eine Datentabelle erstellen, um die Informationen zu speichern. Sie können den Befehl notifications:table verwenden, um eine Migration zu generieren Datei und generieren Sie dann das entsprechende Datenblatt:

php artisan notifications:table
php artisan migrate

Datenbankbenachrichtigung formatieren

Wenn die Benachrichtigung das Speichern in der Datenbanktabelle unterstützt, muss die Benachrichtigungsklasse eine toDatabase- oder toArray-Methode definieren. Diese Methode akzeptiert eine $notifiable-Entität als Parameter und gibt ein natives PHP-Array zurück. Die zurückgegebenen Daten werden als JSON codiert und in der Spalte notifications der Tabelle data gespeichert. Schauen wir uns ein Beispiel der toArray-Methode an:

/**
 * 获取通知的数组表示。
 *
 * @param  mixed  $notifiable
 * @return array
 */
 public function toArray($notifiable){
     return [      
       'invoice_id' => $this->invoice->id,        
       'amount' => $this->invoice->amount,  
         ];
    }

toDatabase Vs. toArray

toArray Die Methode kann auch den broadcast-Kanal verwenden, um zu bestimmen, welche Daten wird an den JavaScript-Client gesendet. Wenn Sie zwei verschiedene Array-Darstellungen für die Kanäle database und broadcast haben, müssen Sie die Methode toDatabase anstelle der Methode toArray definieren.

Zugriff auf Benachrichtigungen

Sobald Benachrichtigungen in der Datenbank gespeichert sind, sind geeignete Methoden erforderlich, um von der benachrichtigenden Entität aus auf sie zuzugreifen. Das in Lareval enthaltene Standardmodell AppUser verfügt über das Merkmal IlluminateNotificationsNotifiable, dessen notifications Eloquent-bezogene Methoden Entitätsbenachrichtigungen zurückgeben können. Um Benachrichtigungen zu erhalten, können Sie auf diese Methode wie auf andere Eloquent-bezogene Methoden zugreifen. Standardmäßig werden Benachrichtigungen nach created_at Zeitstempel sortiert:

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

Um nur „ungelesene“ Benachrichtigungen zu erhalten, können Sie die Zuordnungsmethode unreadNotifications verwenden. Ebenso sind diese Benachrichtigungen nach created_at Zeitstempel sortiert:

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

{tip} Um auf Benachrichtigungen von einem JavaScript-Client zuzugreifen, müssen Sie einen Benachrichtigungscontroller für Ihre Anwendung definieren, der Benachrichtigungen für meldepflichtige Entitäten zurückgibt . Zum Beispiel der aktuelle Benutzer. HTTP-Anfragen können von einem JavaScript-Client an diesen Controller-URI gesendet werden.

Benachrichtigung als gelesen markieren

Nachdem ein Benutzer eine Benachrichtigung gelesen hat, möchte man sie häufig als „gelesen“ markieren. . Das Merkmal IlluminateNotificationsNotifiable stellt die Methode markAsRead bereit, die die Spalte read_at des Benachrichtigungsdatensatzes in der Datenbank aktualisiert:

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

kann direkt in der Benachrichtigungskontrollsammlung markAsRead verwendet werden Methode statt Benachrichtigungen in einer Schleife aufzurufen:

$user->unreadNotifications->markAsRead();

Sie können Finger-Update auch verwenden, um alle Benachrichtigungen als gelesen zu markieren, ohne sie aus der Datenbank zu lesen:

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

Sie können delete verwenden Methode zum Löschen der gesamten Benachrichtigung aus der Tabelle:

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

Broadcast-Benachrichtigung

Vorläufig Wissen

Bevor Sie Benachrichtigungen senden, müssen Sie die Ereignisübertragung von Laravel konfigurieren und damit vertraut sein Aufschlag. Die Ereignisübertragung bietet dem JavaScript-Client die Möglichkeit, auf vom Server ausgelöste Laravel-Ereignisse zu reagieren.

Formatierte Broadcast-Benachrichtigungen

broadcast kanalisiert Broadcast-Benachrichtigungen mithilfe des Event-Broadcasting-Dienstes von Laravel, der es JavaScript-Clients ermöglicht, Benachrichtigungen in Echtzeit zu erfassen. Wenn die Benachrichtigung Broadcasting unterstützt, müssen Sie die Methode toBroadcast für die Benachrichtigungsklasse definieren. Diese Methode akzeptiert $notifiable-Entitäten als Parameter und gibt BroadcastMessage-Instanzen zurück. Die zurückgegebenen Daten werden als JSON codiert und an den JavaScript-Client gesendet. Schauen wir uns ein toBroadcastMethodenbeispiel

use Illuminate\Notifications\Messages\BroadcastMessage;/**
 * 获取通知的可广播表示。
 *
 * @param  mixed  $notifiable
 * @return BroadcastMessage
 */
 public function toBroadcast($notifiable){ 
    return new BroadcastMessage([      
      'invoice_id' => $this->invoice->id,        
      'amount' => $this->invoice->amount,   
      ]);
   }

Broadcast-Warteschlangenkonfiguration

Alle Broadcast-Benachrichtigungen werden in die Broadcast-Warteschlange gestellt. Um die Warteschlangenverbindung oder den Warteschlangennamen für Broadcast-Vorgänge zu konfigurieren, müssen Sie die Methoden BroadcastMessage und onConnection von onQueue verwenden:

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

{tip} Zusätzlich zu den angegebenen Daten Broadcast-Benachrichtigungen enthalten auch das Feld type, das den Klassennamen der Benachrichtigungsklasse enthält.

Auf Benachrichtigungen warten

Benachrichtigungen werden auf dem privaten Kanal im Format {notifiable}.{id} gesendet, wenn Sie also senden möchten eine Benachrichtigung an die 1-Instanz mit der ID AppUser, dann erfolgt die Benachrichtigung im privaten Kanal Senden Sie auf App.User.1. Wenn Sie Laravel Echo verwenden, können Sie die Hilfsfunktion notification verwenden, um ganz einfach auf Benachrichtigungen auf einem Kanal zu warten:

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

Benutzerdefinierter Benachrichtigungskanal

Wenn Sie möchten Passen Sie die benachrichtigte Entität an, um Broadcast-Benachrichtigungen auf einem bestimmten Kanal zu erhalten. Sie können ein receivesBroadcastNotificationsOn für die benachrichtigte Entität definieren. Methode:

<?php
    namespace App;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Broadcasting\PrivateChannel;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{    use Notifiable;   
     /**
     * 用户接收广播通知的通道。
     *
     * @return string
     */   
    public function receivesBroadcastNotificationsOn()   
     {     
        return 'users.'.$this->id;   
      }
   }

Textnachricht (SMS)-Benachrichtigung

Vorkenntnisse

Laravel basiert auf Nexmo Um SMS-Benachrichtigungen zu senden, müssen Sie vor der Verwendung von Nexmo zum Senden von Benachrichtigungen das entsprechende Composer-Abhängigkeitspaket laravel/nexmo-notification-channel installieren:

composer require laravel/nexmo-notification-channel

Als nächstes müssen Sie es in der Konfigurationsdatei entsprechend konfigurieren config/services.php. Sie können sich auf die folgende Beispielkonfiguration beziehen:

'nexmo' => [ 
   'key' => env('NEXMO_KEY'),    
   'secret' => env('NEXMO_SECRET'),    
   'sms_from' => '15556666666',
],

sms_from Das Konfigurationselement ist die Mobiltelefonnummer, die Sie zum Senden von SMS-Nachrichten verwenden. Sie müssen eine Mobiltelefonnummer für die Anwendung im Nexmo-Kontrollfeld generieren .

Formatierte SMS-Benachrichtigung

Wenn die Benachrichtigung das Senden per SMS unterstützt, müssen Sie eine toNexmo-Methode für die Benachrichtigungsklasse definieren. Diese Methode empfängt eine $notifiable-Entität und gibt eine IlluminateNotificationsMessagesNexmoMessage-Instanz zurück:

/**
 * Get the Nexmo / SMS representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return NexmoMessage
 */
 public function toNexmo($notifiable){ 
    return (new NexmoMessage)             
       ->content('Your SMS message content');
   }

Unicode-Inhalt

Wenn Ihre SMS-Nachricht Unicode-Zeichen enthält, müssen Sie beim Erstellen des <🎜 <🎜 aufrufen > Instanz > Methode: NexmoMessage

/**
 * Get the Nexmo / SMS representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return NexmoMessage
 */
 public function toNexmo($notifiable){ 
    return (new NexmoMessage)             
       ->content('Your unicode message')                
       ->unicode();
    }

Benutzerdefinierte „Sende“-Nummer

Wenn Sie Benachrichtigungen über eine andere Nummer als die in der Konfigurationsdatei config/services.php angegebene Telefonnummer senden möchten, können Sie NexmoMessage auf der from-Instanz verwenden Methode:

/**
 * Get the Nexmo / SMS representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return NexmoMessage
 */
 public function toNexmo($notifiable){ 
    return (new NexmoMessage)             
       ->content('Your SMS message content')                
       ->from('15554443333');
   }

SMS-Benachrichtigungsroute

Beim Senden einer Benachrichtigung über den nexmo-Kanal sucht das Benachrichtigungssystem automatisch nach der benachrichtigten Person Entität phone_number Eigenschaften. Wenn Sie die Telefonnummer anpassen möchten, an die Benachrichtigungen gesendet werden, können Sie eine routeNotificationForNexmo-Methode für diese Entität definieren:

<?php
    namespace App;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{  
      use Notifiable;    
      /**
     * Route notifications for the Nexmo channel.
     *
     * @param  \Illuminate\Notifications\Notification  $notification
     * @return string
     */  
    public function routeNotificationForNexmo($notification) 
       {      
         return $this->phone;   
        }
    }

Slack Benachrichtigungen

Vorkenntnisse

Bevor Benachrichtigungen über Slack gesendet werden, muss der Slack-Benachrichtigungskanal über Composer installiert werden:

composer require laravel/slack-notification-channel

Darüber hinaus müssen Sie auch einen „Incoming Webhook“ für die Slack-Gruppe konfigurieren Integriert. Die Integration stellt eine URL bereit, wenn Sie Slack-Benachrichtigungsweiterleitung durchführen.

Formatieren von Slack-Benachrichtigungen

Wenn Benachrichtigungen das Senden über Slack-Nachrichten unterstützen, müssen Sie eine toSlack-Methode für die Benachrichtigungsklasse definieren, die Die Methode empfängt eine $notifiable-Entität und gibt eine IlluminateNotificationsMessagesSlackMessage-Instanz zurück, die den Textinhalt und formatierte zusätzliche Text- oder Array-Felder enthält "Anhang". Schauen wir uns ein einfaches Anwendungsbeispiel von toSlack an:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){
     return (new SlackMessage)            
         ->content('One of your invoices has been paid!');
      }

In diesem Beispiel senden wir einfach eine einfache Textzeile an Slack und die endgültige erstellte Nachricht lautet wie folgt:

Anpassen des Absenders & Empfänger

Sie können den Absender und Empfänger mithilfe der Methoden from und to anpassen. Die Methode from erhält einen Benutzernamen und eine Emoji-Kennung, während die Methode to einen Kanal oder Benutzernamen erhält:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){ 
    return (new SlackMessage)           
         ->from('Ghost', ':ghost:')                
         ->to('#other')                
         ->content('This will be sent to #other');
     }

Sie können auch Bilder als Logos zum Ersetzen verwenden Emoji:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){ 
    return (new SlackMessage)              
      ->from('Laravel')                
      ->image('https://laravel.com/favicon.png')                
      ->content('This will display the Laravel logo next to the message');
   }

Slack-Anhänge

Sie können Slack-Nachrichten auch „Anhänge“ hinzufügen. Im Vergleich zu einfachen Textnachrichten bieten Anhänge eine umfangreichere Formatauswahl. In diesem Beispiel senden wir eine Benachrichtigung über einen Ausnahmefehler, der in der Anwendung aufgetreten ist, einschließlich eines Links zum Anzeigen weiterer Ausnahmedetails:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){ 
    $url = url('/exceptions/'.$this->exception->id);    
    return (new SlackMessage)              
      ->error()                
      ->content('Whoops! Something went wrong.')                
      ->attachment(function ($attachment) use ($url) {       
                   $attachment->title('Exception: File Not Found', $url) 
                            ->content('File [background.jpg] was not found.');               
                    });
           }

Der obige Code generiert die folgende Slack-Nachricht:

Mit dem Anhang können Sie auch Array-Daten angeben, die dem Benutzer angezeigt werden sollen. Um die Lesbarkeit zu verbessern, wird das angegebene Array in tabellarischer Form angezeigt:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){
     $url = url('/invoices/'.$this->invoice->id);    
     return (new SlackMessage)             
        ->success()                
        ->content('One of your invoices has been paid!')                
        ->attachment(function ($attachment) use ($url) {              
              $attachment->title('Invoice 1322', $url)                             
                       ->fields([                                   
                        'Title' => 'Server Expenses',                                    
                        'Amount' => ',234',                                    
                        'Via' => 'American Express',                                    
                        'Was Overdue' => ':-1:',                                
                        ]);              
          });
     }

Der obige Code generiert die folgende Slack-Nachricht:

Markdown-Anhangsinhalt

Wenn einige Anhangsfelder Markdown enthalten, können Sie die markdown-Methode verwenden, um Slack zu erstellen und die im Markdown-Format geschriebenen Anhangsfelder zu analysieren und anzuzeigen Zu dieser Methode gehören pretext, text oder fields. Weitere Informationen zur Slack-Formatierung finden Sie in der Slack API-Dokumentation:

/**
 * Get the Slack representation of the notification.
 *
 * @param  mixed  $notifiable
 * @return SlackMessage
 */
 public function toSlack($notifiable){
     $url = url('/exceptions/'.$this->exception->id);    
     return (new SlackMessage)             
        ->error()                
        ->content('Whoops! Something went wrong.')                
        ->attachment(function ($attachment) use ($url) {                  
             $attachment->title('Exception: File Not Found', $url)                            
                ->content('File [background.jpg] was *not found*.')                              
                ->markdown(['text']);            
              });
       }

Slack Notification Routing

To route Um Slack-Benachrichtigungen an den entsprechenden Ort zu senden, müssen Sie ein routeNotificationForSlack für die zu benachrichtigende Entität definieren -Methode, die die Webhook-URL zurückgibt, an die die Benachrichtigung gesendet wurde. Webhook-URLs können durch Hinzufügen eines „Incoming Webhook“-Dienstes zu einer Slack-Gruppe generiert werden:

<?php
    namespace App;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{  
      use Notifiable;   
     /**
     * Route notifications for the Slack channel.
     *
     * @param  \Illuminate\Notifications\Notification  $notification
     * @return string
     */   
    public function routeNotificationForSlack($notification) 
       {     
          return 'https://hooks.slack.com/services/...';  
        }
     }

Lokalisierte Benachrichtigungen

Laravel ermöglicht Ihnen Benachrichtigungen werden in einer anderen Sprache als dem aktuellen Gebietsschema gesendet und das Gebietsschema wird bei der Benachrichtigung der Warteschlange gespeichert.

Um dies zu erreichen, stellt die Klasse IlluminateNotificationsNotification eine Methode locale bereit, um die gewünschte Sprache festzulegen. Beim Formatieren einer Benachrichtigung wechselt die Anwendung zu dieser Spracheinstellung und kehrt nach Abschluss der Formatierung zur vorherigen Spracheinstellung zurück:

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

Die Lokalisierung mehrerer Benachrichtigungen ist auch über die Notification Fassade möglich:

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

Bevorzugtes Gebietsschema des Benutzers

In einigen Fällen speichert die Anwendung das bevorzugte Gebietsschema für jeden Benutzer. Durch die Implementierung des HasLocalePreference-Vertrags auf Ihrem Modell können Sie festlegen, dass Laravel beim Senden von Benachrichtigungen die gespeicherte bevorzugte Spracheinstellung des Benutzers verwendet:

use Illuminate\Contracts\Translation\HasLocalePreference;
class User extends Model implements HasLocalePreference{   
    /**
     * Get the user's preferred locale.
     *
     * @return string
     */    
   public function preferredLocale() 
      {      
        return $this->locale;    
      }
    }

Nach der Implementierung der Schnittstelle verwendet Laravel beim Senden von Benachrichtigungen automatisch das bevorzugte Gebietsschema E-Mails an Ihr Modell einrichten. Daher ist es nicht erforderlich, die Methode locale aufzurufen, wenn Sie diese Schnittstelle verwenden:

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

Benachrichtigungsereignis

Wenn die Benachrichtigung gesendet wird , löst das Benachrichtigungssystem ein IlluminateNotificationsEventsNotificationSent-Ereignis aus, das die zu benachrichtigende Entität (z. B. den Benutzer) und die Benachrichtigungsinstanz selbst enthält. Sie können einen Listener für dieses Ereignis in EventServiceProvider registrieren:

/**
 * The event listener mappings for the application.
 *
 * @var array
 */
 protected $listen = [ 
    'Illuminate\Notifications\Events\NotificationSent' => [     
       'App\Listeners\LogNotification',  
      ],
  ];

{Tipp} Nachdem Sie den Listener in EventServiceProvider registriert haben, verwenden Sie den Artisan-Befehl event:generate, um schnell die Listener-Klasse zu generieren.

Im Ereignis-Listener können Sie auf die notifiable, notification und channel des Ereignisses zugreifen Eigenschaften, um mehr über den Benachrichtigungsempfänger und die Benachrichtigung selbst zu erfahren:

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

Benutzerdefinierte Kanäle

Laravel stellt uns eine Vielzahl von Benachrichtigungskanälen zur Verfügung. Aber auch der Versuch, einen benutzerdefinierten Kanaltreiber zu schreiben, um Benachrichtigungen über andere Kanäle zu senden, ist einfach. Definieren Sie zunächst eine Klasse mit der Methode send, die zwei Parameter erhält: $notifiable und $notification:

<?php
    namespace App\Channels;
    use Illuminate\Notifications\Notification;class VoiceChannel{   
     /**
     * 发送指定的通知.
     *
     * @param  mixed  $notifiable
     * @param  \Illuminate\Notifications\Notification  $notification
     * @return void
     */  
    public function send($notifiable, Notification $notification)  
      {       
        $message = $notification->toVoice($notifiable);        
        // Send notification to the $notifiable instance...   
       }
    }

Sobald die Benachrichtigungskanalklasse definiert ist, kann der Klassenname in der Anwendung über die via-Methode zurückgegeben werden:

<?php
    namespace App\Notifications;
    use Illuminate\Bus\Queueable;
    use App\Channels\VoiceChannel;
    use App\Channels\Messages\VoiceMessage;
    use Illuminate\Notifications\Notification;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class InvoicePaid extends Notification{   
     use Queueable; 
    /**
     * 获取通知通道.
     *
     * @param  mixed  $notifiable
     * @return array|string
     */  
   public function via($notifiable)  
     {      
       return [VoiceChannel::class];   
     }  
    /**
     * 获取语音表示的通知.
     *
     * @param  mixed  $notifiable
     * @return VoiceMessage
     */ 
   public function toVoice($notifiable)  
     {     
        // ...  
      }
   }