Mail

Question 1

How can you create a database table to hold your notifications using Artisan?

Answer 1

php artisan make:notifications-table

php artisan migrate

Question 2

If a notification supports being stored in a database table, you should define a toDatabase or toArray method on the notification class. What would this method do?

Answer 2

It will receive a $notifiable entity and should return a plain PHP array. The returned array will be encoded as JSON and stored in the data column of your notifications table.

Question 3

What is the difference between using toDatabase or toArray?

Answer 3

The toArray method is also used by the broadcast channel to determine which data to broadcast to your JavaScript powered frontend. If you would like to have two different array representations for the database and broadcast channels, you should define a toDatabase method instead of a toArray method.

Question 4

How can you mark a users notifications as read?

Answer 4

assuming that the user was already specified and set as $user:

$user->unreadNotifications()->markAsRead();

Question 5

Where can you find when a notification was read by a user on the notifications database record?

Answer 5

In the read_at column

Question 6

All broadcast notifications are queued for broadcasting. If you would like to configure the queue connection or queue name that is used to queue the broadcast operation, how can you do that?

Answer 6

You may use the onConnection and onQueue methods of the BroadcastMessage:

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

Question 7

How can you customize the type of your notification?

Answer 7

public function broadcastType(): string
{
    return 'broadcast.message';
}

Question 8

Notifications will broadcast on a private channel formatted using a {notifiable}.{id} convention. So, if you are sending a notification to an App\Models\User instance with an ID of 1, what will the notification’s private channel be called?

Answer 8

App.Models.User.1

Question 9

What do you need to call a method that customizes which channel an entity’s broadcast notifications are broadcast on?

Answer 9

public function receivesBroadcastNotificationsOn(): string
{
    return 'example.'.$this->id;
}

In this example, the channel would be called example.x with x being the ID of the broadcast notification.

Question 10

What component does Laravel use for SMS notifications?

Answer 10

Vonage

Question 11

What is the name of the environmental variable that defines the phone number that your SMS messages should be sent from by default?

Answer 11

VONAGE_SMS_FROM

Question 12

How can you send notifications from a phone number that is different than the default one set by the environmental variable?

Answer 12

->from('insert number here');

Question 13

How can you keep track of costs per user, team or client?

Answer 13

By adding a client reference to the notification. Vonage will allow you to generate reports using this client reference so that you can better understand a particular customer’s SMS usage. The client reference can be any string up to 40 characters:

public function toVonage(object $notifiable): VonageMessage
{
    return (new VonageMessage)
                ->clientReference((string) $notifiable->id)
                ->content('Your SMS message content');
}

Question 14

Which method do you need to use to route Vonage notifications to the proper phone number?

Answer 14

public function routeNotificationForVonage(Notification $notification): string
{
    return $this->phone_number;
}

Question 15

What do you need to install before being able to send Slack notifications? Give the installation command using composer!

Answer 15

composer require laravel/slack-notification-channel

Additionally, you must create a Slack App for your Slack workspace.

Question 16

How should you name the method that generates Slack notifications and what should it return?

Answer 16

public function toSlack(object $notifiable): SlackMessage

Question 17

Define a toSlack method that returns a text, headerBlock, contextBlock, sectionBlock and actionsBlock that lets the user confirm or deny something through slack!

Answer 17

public function toSlack(object $notifiable): SlackMessage
{
    return (new SlackMessage)
            ->text('One of your invoices has been paid!')
            ->headerBlock('Invoice Paid')
            ->contextBlock(function (ContextBlock $block) {
                $block->text('Customer #1234');
            })
            ->sectionBlock(function (SectionBlock $block) {
                $block->text('An invoice has been paid.');
            })
            ->actionsBlock(function (ActionsBlock $block) {
                $block->button('Acknowledge Invoice')
                    ->primary()
                    ->confirm(
                        'Acknowledge the payment and send a thank you email?',
                        function (ConfirmObject $dialog) {
                            $dialog->confirm('Yes');
                            $dialog->deny('No');
                        }
                    );
            });
}

Question 18

How can you display a preview of the payload and notification you are trying to build for Slack?

Answer 18

->dd();

using dump and die on a SlackMessage instance will generate and dump a URL to Slack’s Block Kit Builder, which displays a preview of the payload and notification in your browser. You may pass true to the dd method to dump the raw payload.

Question 19

Make Slack route its notifications to the “#support-channel” Slack channel!

Answer 19

public function routeNotificationForSlack(Notification $notification): mixed
{
    return '#support-channel';
}

Question 20

When defining a custom notification channel for Laravel, which methods do you need to include, which arguments does that method need and what should it do?

Answer 20

Within the class for the custom channel, you need to create a send function that receives a $notifiable object and and a Notification $notification. It should return void and within the send method you may call methods on the notification to retrieve a message object understood by your channel and then send the notification to the $notifiable instance however you wish. To just give an example:

public function send(object $notifiable, Notification $notification): void
{
    $message = $notification->toVoice($notifiable);
    // Send notification to the $notifiable instance...
}

Question 21

Where can you configure your applications mail configuration file?

Answer 21

config/mail.php

Each mailer configured within this file may have its own unique configuration and even its own unique “transport”, allowing your application to use different email services to send certain email messages.

Question 22

Generate a mailable class using Artisan!

Answer 22

php artisan make:mail ExampleMailing

Question 23

What do the envelope and content methods of a mailable class do?

Answer 23

The envelope method returns an Illuminate\Mail\Mailable\Envelope object that defines the subject and, sometimes, the recipients of the message. The content method returns an Illuminate\Mail\Mailables\Content object that defines the Blade template that will be used to generate the message content.

Question 24

How can you set the sender and subject of the email in the envelope?

Answer 24

return new Envelope(
    from: new Address('example@example.com', 'Max Mustermann'),
    subject: 'Your example has been exampled',
);

Question 25

Within the config/mail.php configuration file, how can you set up a global email address to be used for all sent mails?

Answer 25

``` 'from' => [ 'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'), 'name' => env('MAIL_FROM_NAME', 'Example'), ], ``` MAIL_FROM_ADDRESS and MAIL_FROM_NAME are environmental variables that should be set in the config/mail.php file if you wish to set them.

Question 26

How can you set up which Blade template to use for the email's content?

Answer 26

``` public function content(): Content { return new Content( view: 'mail.orders.shipped', ); } ``` In this case, the shipped Blade template would be used as the main content of the email.

Question 27

Define the content for an email. so that there is a full Blade version, but also a plain text version of the mail available!

Answer 27

``` return new Content( html: 'mail.orders.shipped', text: 'mail.orders.shipped-text' ); ``` html and view are interchangeable when defining your content, so this does the same thing as this would do: ``` return new Content( view: 'mail.orders.shipped', text: 'mail.orders.shipped-text' ); ```

Question 28

How can you add an attachment to your mails inside of the related mailable's class?

Answer 28

``` public function attachments(): array { return [ Attachment::fromPath('/path/to/file'), ]; } ```

Question 29

If you have stored a file on one of your filesystem disks, how can you attach it to the email?

Answer 29

Using the fromStorage attachment method: ``` return [ Attachment::fromStorage('/path/to/file'), ]; ```

Question 30

How can you embed inline images into your emails?

Answer 30

By using the embed method of the $message variable within your email template. For example: ``` Here is an image: ``` The $message variable is automatically made available to all your email templates thanks to Laravel, so you don't need to pass it manually.

Question 31

How can you attach objects onto emails?

Answer 31

First you need to implement the Illuminate\Contracts\Mail\Attachable interface on the object that will be attachable to messages. This interface dictates that your class defines a toMailAttachment method that returns an Illuminate\Mail\Attachment instance.

Question 32

Generate a mailable with a corresponding Markdown template!

Answer 32

php artisan make:mail OrderShipped --markdown=mail.orders.shipped You can use the markdown when configuring the mailable Content definition within its content method instead of the view parameter

Question 33

How can you export all of the Markdown mail components to your own application for customization?

Answer 33

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

Question 34

Which method of the Mail facade is used to send an email?

Answer 34

Calling the to method on the Mail facade accepts an email address, a user instance, or a collection of users. If you pass an object or collection of objects, the mailer will automatically use their email and name properties when determining the email's recipients, so make sure these attributes are available on your objects. Once you have cpecified your recipients, you may pass an instance of your mailable class to the send method.

Question 35

How can you set the cc and bcc recipients?

Answer 35

By chaining their respective methods together: ``` Mail::to($request->user()) ->cc($moreUsers) ->bcc($evenMoreUsers) ->send(new OrderShipped($order)); ```

Question 36

Occasionally, you may need to send a mailable to a list of recipients by iterating over an array of recipients / email addresses. However, there is a problem you will run into when trying to do that. Explain the issue!

Answer 36

Since the to method appends email addresses to the mailable's list of recipients, each iteration through the loop will send another email to every previous recipient. Therefore, you should always re-create the mailable instance for each recipient.

Question 37

How can you add mails onto the queue?

Answer 37

The queue method on the Mail facade will automatically take care of queueing your mails after specifying the message's recipients.

Question 38

If you wish to delay the delivery of a queued email, which method should you use and which arguments does it accept?

Answer 38

The later method accepts a DateTime instance as its first argument and the mailable object as the second one. For example: ``` Mail::to($request->user()) ->cc($moreUsers) ->bcc($evenMoreUsers) ->later(now()->addMinutes(10), new OrderShipped($order)); ```

Question 39

If you have a mailable class that you always want to be queued, how can you assure that everything in that class gets queued by default?

Answer 39

You may implement the ShouldQueue contract on the class. Now, even if you call the send method when mailing, the mailable will still be queued since it implements the contract

Question 40

When queued mailables are dispatched within database transactions, they may be processed by the queue before the database transaction has been committed. When this happens, any updates you have made to models or database records during the database transaction may not yet be reflected in the database. In addition, any models or database records created within the transaction may not exist in the database. If your mailable depends on these models, unexpected errors can occur when the job that sends the queued mailable is processed. What can you do about this?

Answer 40

If your queue connection's after_commit configuration option is set to false, you may still indicate that a particular queued mailable should be dispatched after all open database transactions have been committed by calling the afterCommit method when sending the mail message. Alternatively, you may call the afterCommit method from your mailable's constructor.