{Note:} When sending email notification, make sure that name is set in the configuration file config/app.php value, which will be used in the header and trailer of the email notification message.

Other notification formatting options

In addition to defining multi-line text in the notification class, you can also use the view method to specify a custom , a template for rendering notification emails:

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

Additionally, you can return a mailable object from the toMail method:

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);
  }

Error Message

Some notifications will inform users of error messages, such as failed order payments. You can call the error method when constructing the message to indicate that the email message represents error information. When using the error method in an email message, the action button will turn red:

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

Custom Recipient

When sending a notification through the mail channel, the notification system will automatically look for the email attribute on the notified entity. You can define a routeNotificationForMail on the entity. To customize which email address to use to send notifications:

<?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;   
      }
  }

Customize the subject

By default, the subject of the email is in the format of "Title style ” notification class name, therefore, if the notification class is named InvoicePaid, the subject of the email is Invoice Paid. If you want to specify an explicit subject for the message, you can build the message When calling the subject method:

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

Custom template

You can publish the resources of the notification extension package. Modify the HTML and plain text templates used for email notifications. After running the following command, the email notification template will be stored in the resources/views/vendor/notifications directory:

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

Markdown Email Notifications

Markdown Email notifications allow you to take advantage of pre-built templates for email notifications, giving you the freedom to write longer, more personalized messages. Because these messages are written in Markdown format, Laravel can also render them into beautiful, responsive HTML templates while automatically generating plain text copies.

Generate message

To generate a notification with the corresponding Markdown template, you can use the Artisan command make:notification Bring the --markdown option:

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

Like other email notifications, notification classes using Markdown templates must also define a toMail method. However, you can use the markdown method instead of the line and action methods of the constructor notification to specify the Markdown template name to use:

/**
 * 获取通知的邮件表示。
 *
 * @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]);
   }

Writing Message

Markdown email notification uses the Blade component and Markdown syntax, allowing you to easily build notifications without breaking away from Laravel's preset components:

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

Button Component

The button component renders a centered button link. This component receives two parameters, url and optional color. The supported colors are blue, green and red . You can add any number of button components to the message:

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

Panel component

The panel component renders the given text block into a panel with a light background color and Surrounding messages are distinguished. Suitable for blocks of text that require attention:

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

Table component

The Table component allows you to convert a Markdown table into an HTML table. This component receives a Markdown table as its content. Table column alignment supports using the default Markdown table column alignment syntax:

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

Custom component

You can export all Markdown notification components to the application To customize, to export the component, use the Artisan command vendor:publish to publish laravel-mail Resource tag:

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

This command will publish the Markdown email notification component Go to the resources/views/vendor/mail directory. The mail directory contains the html and markdown directories, each of which contains all of its valid components. You are free to edit these components to your liking.

Custom CSS

After exporting the component, the resources/views/vendor/mail/html/themes directory will contain a default default.css file, you can customize the CSS in this file, so that the HTML style of the Markdown notification will be automatically adjusted.

{Note:} If you want to build a completely new theme for the Markdown component, just write a new CSS file in the html/themes directory and modify The theme option of the mail configuration file is enough.

Database notification

database Notification channels store notification information in a data table that contains information such as the notification type and custom JSON data describing the notification.

notifications:table command to generate migrations. The file is then used to generate the corresponding data table:

php artisan notifications:table
php artisan migrate

Format database notification

If the notification supports saving to the database table, the notification class needs to define the toDatabase or toArray method. This method accepts a $notifiable entity as parameter and returns a native PHP array. The returned data will be encoded as JSON and stored into the data column of the notifications table. Let’s look at an example of the toArray method:

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

toDatabase Vs. toArray

toArray method You can also use the broadcast channel to determine which data is broadcast to the JavaScript client. If you have two different array representations for the database and broadcast channels, you need to define the toDatabase method instead of the toArray method.

Accessing Notifications

Once notifications are stored in the database, appropriate methods are needed to access them from the notifying entity. The default App\User model included with Lareval has the Illuminate\Notifications\Notifiable trait, and its notifications Eloquent associated methods can return entity notifications. To get notifications, you can access this method like other Eloquent related methods. By default, notifications are sorted by created_at timestamp:

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

To get only "unread" notifications, you can use the unreadNotifications association method. Again these notifications are sorted by created_at timestamp:

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

{tip} To access notifications from a JavaScript client, you need to define a notification controller for your application that returns a notification Notifications for entities, such as the current user. HTTP requests can be sent to this controller URI from a JavaScript client.

Mark notification as read

Typically, after a user reads a notification, you want to mark it as "read" ”. The Illuminate\Notifications\Notifiable trait provides the markAsRead method, which updates the read_at column of the notification record in the database:

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

can be used in the notification control Use the markAsRead method directly on the collection instead of circularly calling notifications:

$user->unreadNotifications->markAsRead();

You can also use finger updates to mark all notifications as read without reading them from the database:

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

You can use the delete method to delete the entire notification from the table:

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

Broadcast notification

Preliminary knowledge

Before broadcasting notifications, you need to configure and be familiar with Laravel's event broadcast service. Event broadcasting provides a way for the JavaScript client to respond to Laravel events triggered by the server.

Formatted broadcast notifications

broadcast Channels broadcast notifications using Laravel's event broadcasting service, which allows JavaScript clients to capture notifications in real time. If the notification supports broadcasting, you need to define the toBroadcast method on the notification class. This method accepts a $notifiable entity as a parameter and returns a BroadcastMessage instance. The returned data will be encoded as JSON and broadcast to the JavaScript client. Let's take a look at a toBroadcast method example

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 queue configuration

All broadcast notifications are put into the broadcast queue. To configure the queue connection or queue name for broadcast operations, you need to use the onConnection and onQueue methods of BroadcastMessage:

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

{tip} In addition to the specified data, broadcast notifications also contain the type field, which contains the class name of the notification class.

Listening notifications

Notifications will be formatted as {notifiable}.{id} Forms are broadcast on a private channel, so if you want to send a notification to the App\User instance with ID 1, the notification will be on the private channel App.User .1 to broadcast, if you use Laravel Echo, you can use the helper function notification to easily monitor notifications on a channel:

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

Custom notification channel

If you want to customize the notified entity to receive broadcast notifications on a certain channel, you can define a receivesBroadcastNotificationsOn method on the notified entity:

<?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;   
      }
   }

Text message (SMS) notification

Preliminary knowledge

Laravel sends SMS notification based on Nexmo, Before using Nexmo to send notifications, you need to install the corresponding Composer dependency package laravel/nexmo-notification-channel:

composer require laravel/nexmo-notification-channel

Next step, you need to configure the configuration file config/services.php Configure accordingly. You can refer to the following sample configuration:

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

sms_from The configuration item is the mobile phone number you use to send SMS messages. You need to generate a mobile phone number for the application in the Nexmo control panel.

Format SMS notification

If the notification supports sending by SMS, then you need to define a toNexmo# on the notification class ## method. This method receives a $notifiable entity and returns Illuminate\Notifications\Messages\NexmoMessage instance:

/**
 * 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 method when constructing the NexmoMessage instance:

/**
 * 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();
    }

##

Customize the "send" number

If you want to send notifications through a different number than the mobile phone number specified in the configuration file config/services.php, you can use from method on NexmoMessage instance:

/**
 * 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 notification routing

Use nexmo When the channel sends a notification, the notification system will automatically search for the phone_number attribute on the notified entity. If you want to customize the mobile number to which notifications are sent, you can define a routeNotificationForNexmo method on this entity:

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

Preliminary knowledge

Before sending notifications through Slack, the Slack notification channel must be installed through Composer:

composer require laravel/slack-notification-channel

In addition , you also need to configure an "Incoming Webhook" integration for the Slack group. This integration provides a URL when you Slack notification routing.

Formatting Slack notifications

If notifications support sending via Slack messages, you need to define a toSlack## on the notification class # Method that receives a $notifiable entity and returns an Illuminate\Notifications\Messages\SlackMessage instance containing the text content and "attachments" of formatted extra text or array fields . Let’s look at a basic toSlack usage example:

/**
 * 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!');
      }

from and to methods And the receiver, the from method receives a username and emoji identification, while the to method receives a channel or username:

/**
 * 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');
     }

/**
 * 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');
   }

/**
 * 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.');               
                    });
           }

/**
 * 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:',                                
                        ]);              
          });
     }

/**
 * 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']);            
              });
       }

<?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/...';  
        }
     }

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

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

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;    
      }
    }

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

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

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

<?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...   
       }
    }