Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Mail

Introduzione

Inviare email non deve essere complicato. Laravel offre un’API email pulita e semplice, supportata dal popolare componente Symfony Mailer. Laravel e Symfony Mailer forniscono driver per inviare email tramite SMTP, Mailgun, Postmark, Resend, Amazon SES e sendmail, permettendoti di iniziare rapidamente a inviare mail attraverso un servizio locale o basato sul cloud a tua scelta.

Configurazione

I servizi email di Laravel possono essere configurati tramite il file config/mail.php della tua applicazione. Ogni mailer configurato in questo file può avere una configurazione e un "transport" unici, permettendo alla tua applicazione di usare diversi servizi email per inviare determinati messaggi. Ad esempio, la tua applicazione potrebbe usare Postmark per le email transazionali e Amazon SES per le email di massa.

Nel file di configurazione mail troverai un array di configurazione chiamato mailers. Questo array contiene una configurazione di esempio per ciascuno dei principali driver di posta/transport supportati da Laravel, mentre il valore di configurazione default determina quale mailer verrà usato di default quando la tua applicazione deve inviare un’email.

Prerequisiti del Driver / Transport

I driver basati su API come Mailgun, Postmark, Resend e MailerSend sono spesso più semplici e veloci rispetto all’invio di email tramite server SMTP. Quando possibile, consigliamo di utilizzare uno di questi driver.

Driver Mailgun

Per utilizzare il driver Mailgun, installa il transport Mailgun Mailer di Symfony tramite Composer:

composer require symfony/mailgun-mailer symfony/http-client

Successivamente, imposta l’opzione default nel file di configurazione config/mail.php della tua applicazione su mailgun e aggiungi il seguente array di configurazione al tuo array di mailers:

    'mailgun' => [
        'transport' => 'mailgun',
        // 'client' => [
        //     'timeout' => 5,
        // ],
    ],

Dopo aver configurato il mailer predefinito della tua applicazione, aggiungi le seguenti opzioni al file di configurazione config/services.php:

    'mailgun' => [
        'domain' => env('MAILGUN_DOMAIN'),
        'secret' => env('MAILGUN_SECRET'),
        'endpoint' => env('MAILGUN_ENDPOINT', 'api.mailgun.net'),
        'scheme' => 'https',
    ],

Se non stai utilizzando la regione Mailgun degli Stati Uniti, puoi definire l’endpoint della tua regione nel file di configurazione services:

    'mailgun' => [
        'domain' => env('MAILGUN_DOMAIN'),
        'secret' => env('MAILGUN_SECRET'),
        'endpoint' => env('MAILGUN_ENDPOINT', 'api.eu.mailgun.net'),
        'scheme' => 'https',
    ],

Driver Postmark

Per utilizzare il driver Postmark, installa il transport Postmark Mailer di Symfony tramite Composer:

composer require symfony/postmark-mailer symfony/http-client

Successivamente, imposta l’opzione default nel file di configurazione config/mail.php della tua applicazione su postmark. Dopo aver configurato il mailer predefinito della tua applicazione, assicurati che il file di configurazione config/services.php contenga le seguenti opzioni:

    'postmark' => [
        'token' => env('POSTMARK_TOKEN'),
    ],

Se desideri specificare il flusso di messaggi Postmark che deve essere utilizzato da un determinato mailer, puoi aggiungere l’opzione di configurazione message_stream_id all’array di configurazione del mailer. Questo array di configurazione si trova nel file config/mail.php della tua applicazione:

    'postmark' => [
        'transport' => 'postmark',
        'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
        // 'client' => [
        //     'timeout' => 5,
        // ],
    ],

In questo modo puoi configurare più mailer Postmark con flussi di messaggi diversi.

Driver Resend

Per usare il driver Resend, installa l’SDK PHP di Resend tramite Composer:

composer require resend/resend-php

Successivamente, imposta l’opzione default nel file di configurazione config/mail.php della tua applicazione su resend. Dopo aver configurato il mailer predefinito della tua applicazione, assicurati che il file di configurazione config/services.php contenga le seguenti opzioni:

'resend' => [
    'key' => env('RESEND_KEY'),
],

Driver SES

Per utilizzare il driver Amazon SES devi prima installare l’Amazon AWS SDK per PHP. Puoi installare questa libreria tramite il gestore di pacchetti Composer:

composer require aws/aws-sdk-php

Successivamente, imposta l’opzione default nel file di configurazione config/mail.php su ses e verifica che il file di configurazione config/services.php contenga le seguenti opzioni:

'ses' => [
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
],

Per utilizzare credenziali temporanee di AWS tramite un token di sessione, puoi aggiungere una chiave token alla configurazione SES della tua applicazione:

'ses' => [
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    'token' => env('AWS_SESSION_TOKEN'),
],

Per interagire con le funzionalità di gestione delle sottoscrizioni di SES, puoi restituire l’header X-Ses-List-Management-Options nell’array restituito dal metodo headers di un messaggio email:

/**
 * Ottieni gli header del messaggio.
 */
public function headers(): Headers
{
    return new Headers(
        text: [
            'X-Ses-List-Management-Options' => 'contactListName=MyContactList;topicName=MyTopic',
        ],
    );
}

Se desideri definire opzioni aggiuntive che Laravel dovrebbe passare al metodo SendEmail dell’AWS SDK quando invii un’email, puoi definire un array options all’interno della tua configurazione ses:

'ses' => [
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    'options' => [
        'ConfigurationSetName' => 'MyConfigurationSet',
        'EmailTags' => [
            ['Name' => 'foo', 'Value' => 'bar'],
        ],
    ],
],

Driver MailerSend

MailerSend, un servizio di email transazionali e SMS, offre un proprio driver mail basato su API per Laravel. Il pacchetto contenente il driver può essere installato tramite il gestore di pacchetti Composer:

composer require mailersend/laravel-driver

Una volta installato il pacchetto, aggiungi la variabile d’ambiente MAILERSEND_API_KEY al file .env della tua applicazione. Inoltre, la variabile d’ambiente MAIL_MAILER deve essere definita come mailersend:

MAIL_MAILER=mailersend
MAIL_FROM_ADDRESS=app@yourdomain.com
MAIL_FROM_NAME="App Name"

MAILERSEND_API_KEY=your-api-key

Infine, aggiungi MailerSend all’array mailers nel file di configurazione config/mail.php della tua applicazione:

'mailersend' => [
    'transport' => 'mailersend',
],

Per saperne di più su MailerSend, inclusa l’uso dei template ospitati, consulta la documentazione del driver MailerSend.

Configurazione Failover

A volte, un servizio esterno che hai configurato per inviare le email della tua applicazione potrebbe essere inattivo. In questi casi, può essere utile definire una o più configurazioni di consegna mail di riserva che verranno utilizzate nel caso in cui il tuo driver di consegna principale sia inattivo.

Per fare ciò, dovresti definire un mailer nel file di configurazione mail della tua applicazione che utilizza il transport failover. L’array di configurazione per il mailer failover della tua applicazione dovrebbe contenere un array di mailers che specifica l’ordine in cui i mailer configurati dovrebbero essere scelti per la consegna:

    'mailers' => [
        'failover' => [
            'transport' => 'failover',
            'mailers' => [
                'postmark',
                'mailgun',
                'sendmail',
            ],
        ],

        // ...
    ],

Una volta che il tuo mailer failover è stato definito, dovresti impostare questo mailer come mailer predefinito utilizzato dalla tua applicazione specificandone il nome come valore della chiave di configurazione default all’interno del file di configurazione mail della tua applicazione:

    'default' => env('MAIL_MAILER', 'failover'),

Configurazione Round Robin

Il transport roundrobin ti permette di distribuire il carico di invio delle email su più mailer. Per iniziare, definisci un mailer nel file di configurazione mail della tua applicazione che utilizzi il transport roundrobin. L’array di configurazione per il mailer roundrobin della tua applicazione dovrebbe contenere un array di mailers che indicano quali mailer configurati devono essere usati per la consegna:

'mailers' => [
    'roundrobin' => [
        'transport' => 'roundrobin',
        'mailers' => [
            'ses',
            'postmark',
        ],
    ],

    // ...
],

Una volta definito il tuo mailer round robin, dovresti impostarlo come mailer predefinito utilizzato dalla tua applicazione specificandone il nome come valore della chiave di configurazione default nel file di configurazione mail della tua applicazione:

'default' => env('MAIL_MAILER', 'roundrobin'),

Il round robin seleziona un mailer casuale dalla lista dei mailer configurati e poi passa al mailer successivo disponibile per ogni email successiva. A differenza del transport failover, che aiuta a ottenere l’alta disponibilità, il transport roundrobin fornisce un bilanciamento del carico.

Generazione dei Mailable

Quando crei applicazioni Laravel, ogni tipo di email inviata dalla tua applicazione è rappresentata da una classe "mailable". Queste classi sono memorizzate nella directory app/Mail. Non preoccuparti se non vedi questa directory nella tua applicazione, poiché verrà generata automaticamente quando crei la tua prima classe mailable usando il comando Artisan make:mail:

php artisan make:mail OrderShipped

Scrittura dei Mailables

Una volta generata una classe mailable, aprila per esplorarne il contenuto. La configurazione della classe mailable avviene in diversi metodi, inclusi envelope, content e attachments.

Il metodo envelope restituisce un oggetto Illuminate\Mail\Mailables\Envelope che definisce l’oggetto e, talvolta, i destinatari del messaggio. Il metodo content restituisce un oggetto Illuminate\Mail\Mailables\Content che specifica il template Blade utilizzato per generare il contenuto del messaggio.

Configurare il Mittente

Utilizzo dell’Envelope

Per prima cosa, esploriamo come configurare il mittente dell’email. In altre parole, da chi verrà inviata l’email. Ci sono due modi per configurare il mittente. Innanzitutto, puoi specificare l’indirizzo "from" nell’envelope del tuo messaggio:

use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Envelope;

/**
 * Ottieni l'envelope del messaggio.
 */
public function envelope(): Envelope
{
    return new Envelope(
        from: new Address('jeffrey@example.com', 'Jeffrey Way'),
        subject: 'Ordine Spedito',
    );
}

Se desideri, puoi anche specificare un indirizzo replyTo:

return new Envelope(
    from: new Address('jeffrey@example.com', 'Jeffrey Way'),
    replyTo: [
        new Address('taylor@example.com', 'Taylor Otwell'),
    ],
    subject: 'Ordine Spedito',
);

Utilizzo di un indirizzo from globale

Tuttavia, se la tua applicazione utilizza lo stesso indirizzo "from" per tutte le email, può diventare complicato aggiungerlo a ogni classe mailable che generi. Invece, puoi specificare un indirizzo "from" globale nel file di configurazione config/mail.php. Questo indirizzo verrà utilizzato se non ne viene specificato un altro nella classe mailable:

'from' => [
    'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
    'name' => env('MAIL_FROM_NAME', 'Example'),
],

Inoltre, puoi definire un indirizzo "reply_to" globale nel file di configurazione config/mail.php:

'reply_to' => ['address' => 'example@example.com', 'name' => 'App Name'],

Configurare la Vista

All’interno del metodo content di una classe mailable, puoi definire la view, ovvero quale template utilizzare per rendere il contenuto dell’email. Poiché ogni email utilizza tipicamente un Blade template per renderizzare il contenuto, hai tutta la potenza e la comodità del motore di templating Blade quando costruisci l’HTML della tua email:

/**
 * Get the message content definition.
 */
public function content(): Content
{
    return new Content(
        view: 'mail.orders.shipped',
    );
}

Potresti voler creare una directory resources/views/emails per contenere tutti i tuoi template email; tuttavia, sei libero di posizionarli dove preferisci all’interno della directory resources/views.

Email in Testo Semplice

Se desideri definire una versione in testo semplice della tua email, puoi specificare il template di testo semplice quando crei la definizione Content del messaggio. Come il parametro view, il parametro text deve essere un nome di template che verrà utilizzato per renderizzare il contenuto dell’email. Sei libero di definire sia una versione HTML che una in testo semplice del tuo messaggio:

    /**
     * Get the message content definition.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.orders.shipped',
            text: 'mail.orders.shipped-text'
        );
    }

Per chiarezza, il parametro html può essere usato come alias del parametro view:

    return new Content(
        html: 'mail.orders.shipped',
        text: 'mail.orders.shipped-text'
    );

Dati della Vista

Tramite Proprietà Pubbliche

Tipicamente, vorrai passare alcuni dati alla tua vista che puoi utilizzare quando renderizzi l’HTML dell’email. Ci sono due modi per rendere i dati disponibili alla tua vista. Innanzitutto, qualsiasi proprietà pubblica definita nella tua classe mailable sarà automaticamente disponibile nella vista. Ad esempio, puoi passare i dati nel costruttore della tua classe mailable e impostarli su proprietà pubbliche definite nella classe:

<?php

namespace App\Mail;

use App\Models\Order;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;

class OrderShipped extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Crea una nuova istanza del messaggio.
     */
    public function __construct(
        public Order $order,
    ) {}

    /**
     * Ottieni la definizione del contenuto del messaggio.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.orders.shipped',
        );
    }
}

Una volta che i dati sono stati impostati su una proprietà pubblica, saranno automaticamente disponibili nella tua vista, quindi puoi accedervi come faresti con qualsiasi altro dato nei tuoi template Blade:

<div>
    Price: {{ $order->price }}
</div>

Tramite il parametro with:

Se desideri personalizzare il formato dei dati della tua email prima che venga inviato al template, puoi passare manualmente i tuoi dati alla view tramite il parametro with della definizione Content. Di solito, passerai comunque i dati tramite il costruttore della classe mailable; tuttavia, dovresti impostare questi dati come proprietà protected o private in modo che non siano automaticamente disponibili nel template:

<?php

namespace App\Mail;

use App\Models\Order;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;

class OrderShipped extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Create a new message instance.
     */
    public function __construct(
        protected Order $order,
    ) {}

    /**
     * Get the message content definition.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.orders.shipped',
            with: [
                'orderName' => $this->order->name,
                'orderPrice' => $this->order->price,
            ],
        );
    }
}

Una volta che i dati sono stati passati al metodo with, saranno automaticamente disponibili nella tua view, quindi potrai accedervi come faresti con qualsiasi altro dato nei tuoi template Blade:

<div>
    Price: {{ $orderPrice }}
</div>

Allegati

Per aggiungere allegati a un’email, devi aggiungere gli allegati all’array restituito dal metodo attachments del messaggio. Per prima cosa, puoi aggiungere un allegato fornendo un percorso di file al metodo fromPath offerto dalla classe Attachment:

use Illuminate\Mail\Mailables\Attachment;

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromPath('/path/to/file'),
    ];
}

Quando alleghi file a un messaggio, puoi anche specificare il nome visibile e/o il tipo MIME per l’allegato usando i metodi as e withMime:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromPath('/path/to/file')
                ->as('name.pdf')
                ->withMime('application/pdf'),
    ];
}

Allegare File dal Disco

Se hai salvato un file su uno dei tuoi filesystem disks, puoi allegarlo all’email usando il metodo di allegato fromStorage:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromStorage('/path/to/file'),
    ];
}

Naturalmente, puoi anche specificare il nome e il tipo MIME dell’allegato:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromStorage('/path/to/file')
                ->as('name.pdf')
                ->withMime('application/pdf'),
    ];
}

Il metodo fromStorageDisk può essere usato se hai bisogno di specificare un disco di archiviazione diverso dal disco predefinito:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromStorageDisk('s3', '/path/to/file')
                ->as('name.pdf')
                ->withMime('application/pdf'),
    ];
}

Allegati Raw

Il metodo di allegato fromData può essere utilizzato per allegare una stringa di byte grezza come allegato. Ad esempio, potresti usare questo metodo se hai generato un PDF in memoria e vuoi allegarlo all’email senza salvarlo su disco. Il metodo fromData accetta una closure che fornisce i byte dei dati grezzi e il nome che deve essere assegnato all’allegato:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [
        Attachment::fromData(fn () => $this->pdf, 'Report.pdf')
                ->withMime('application/pdf'),
    ];
}

Allegati In-Linea

Inserire immagini direttamente nelle email è solitamente complicato; tuttavia, Laravel offre un modo comodo per allegare immagini alle tue email. Per incorporare un’immagine in linea, usa il metodo embed sulla variabile $message nel tuo template email. Laravel rende automaticamente disponibile la variabile $message a tutti i tuoi template email, quindi non devi preoccuparti di passarla manualmente:

<body>
    Ecco un'immagine:

    <img src="{{ $message->embed($pathToImage) }}">
</body>

La variabile $message non è disponibile nei template di messaggi in testo semplice poiché i messaggi in testo semplice non utilizzano allegati in linea.

Includere allegati di dati grezzi

Se hai già una stringa di dati immagine grezzi che desideri includere in un modello email, puoi chiamare il metodo embedData sulla variabile $message. Quando chiami il metodo embedData, devi fornire un nome file che verrà assegnato all’immagine incorporata:

<body>
    Ecco un'immagine dai dati grezzi:

    <img src="{{ $message->embedData($data, 'example-image.jpg') }}">
</body>

Oggetti Allegabili

Anche se allegare file ai messaggi tramite semplici percorsi di stringa è spesso sufficiente, in molti casi le entità allegabili all’interno della tua applicazione sono rappresentate da classi. Ad esempio, se la tua applicazione sta allegando una foto a un messaggio, potrebbe avere anche un modello Photo che rappresenta quella foto. In questi casi, non sarebbe comodo passare semplicemente il modello Photo al metodo attach? Gli oggetti allegabili ti permettono proprio di fare questo.

Per iniziare, implementa l’interfaccia Illuminate\Contracts\Mail\Attachable sull’oggetto che potrà essere allegato ai messaggi. Questa interfaccia richiede che la tua classe definisca un metodo toMailAttachment che restituisce un’istanza di Illuminate\Mail\Attachment:

<?php

namespace App\Models;

use Illuminate\Contracts\Mail\Attachable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Mail\Attachment;

class Photo extends Model implements Attachable
{
    /**
     * Ottieni la rappresentazione allegabile del modello.
     */
    public function toMailAttachment(): Attachment
    {
        return Attachment::fromPath('/path/to/file');
    }
}

Una volta definito il tuo oggetto allegabile, puoi restituire un’istanza di quell’oggetto dal metodo attachments quando costruisci un messaggio email:

/**
 * Ottieni gli allegati per il messaggio.
 *
 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 */
public function attachments(): array
{
    return [$this->photo];
}

Naturalmente, i dati degli allegati possono essere archiviati su un servizio di archiviazione file remoto come Amazon S3. Pertanto, Laravel permette anche di generare istanze di allegato dai dati archiviati su uno dei dischi del filesystem della tua applicazione:

// Crea un allegato da un file sul tuo disco predefinito...
return Attachment::fromStorage($this->path);

// Crea un allegato da un file su un disco specifico...
return Attachment::fromStorageDisk('backblaze', $this->path);

Inoltre, puoi creare istanze di allegato tramite dati che hai in memoria. Per fare ciò, fornisci una closure al metodo fromData. La closure deve restituire i dati grezzi che rappresentano l’allegato:

return Attachment::fromData(fn () => $this->content, 'Photo Name');

Laravel fornisce anche metodi aggiuntivi che puoi utilizzare per personalizzare i tuoi allegati. Ad esempio, puoi usare i metodi as e withMime per personalizzare il nome del file e il tipo MIME:

return Attachment::fromPath('/path/to/file')
        ->as('Photo Name')
        ->withMime('image/jpeg');

Headers

A volte potresti aver bisogno di aggiungere header aggiuntivi al messaggio in uscita. Ad esempio, potresti dover impostare un Message-Id personalizzato o altri header di testo arbitrari.

Per fare ciò, definisci un metodo headers nella tua mailable. Il metodo headers deve restituire un’istanza di Illuminate\Mail\Mailables\Headers. Questa classe accetta i parametri messageId, references e text. Naturalmente, puoi fornire solo i parametri di cui hai bisogno per il tuo messaggio specifico:

    use Illuminate\Mail\Mailables\Headers;

    /**
     * Ottieni gli header del messaggio.
     */
    public function headers(): Headers
    {
        return new Headers(
            messageId: 'custom-message-id@example.com',
            references: ['previous-message@example.com'],
            text: [
                'X-Custom-Header' => 'Custom Value',
            ],
        );
    }

Tags e Metadata

Alcuni provider di email di terze parti, come Mailgun e Postmark, supportano i "tags" e i "metadata" dei messaggi, che possono essere usati per raggruppare e tracciare le email inviate dalla tua applicazione. Puoi aggiungere tags e metadata a un messaggio email tramite la definizione del tuo Envelope:

use Illuminate\Mail\Mailables\Envelope;

/**
 * Ottieni l'involucro del messaggio.
 *
 * @return \Illuminate\Mail\Mailables\Envelope
 */
public function envelope(): Envelope
{
    return new Envelope(
        subject: 'Ordine Spedito',
        tags: ['shipment'],
        metadata: [
            'order_id' => $this->order->id,
        ],
    );
}

Se la tua applicazione utilizza il driver Mailgun, puoi consultare la documentazione di Mailgun per maggiori informazioni su tags e metadata. Allo stesso modo, puoi consultare la documentazione di Postmark per ulteriori dettagli sul loro supporto per tags e metadata.

Se la tua applicazione utilizza Amazon SES per inviare email, dovresti usare il metodo metadata per aggiungere i SES "tags" al messaggio.

Personalizzare il "Messaggio" Symfony

Le funzionalità di posta di Laravel sono alimentate da Symfony Mailer. Laravel permette di registrare callback personalizzati che verranno invocati con l’istanza del Messaggio Symfony prima di inviare il messaggio. Questo ti offre l’opportunità di personalizzare profondamente il messaggio prima che venga inviato. Per fare ciò, definisci un parametro using nella tua definizione di Envelope:

use Illuminate\Mail\Mailables\Envelope;
use Symfony\Component\Mime\Email;

/**
 * Ottieni l'involucro del messaggio.
 */
public function envelope(): Envelope
{
    return new Envelope(
        subject: 'Ordine Spedito',
        using: [
            function (Email $message) {
                // ...
            },
        ]
    );
}

Markdown Mailable

I messaggi email in formato Markdown ti permettono di sfruttare i template e i componenti predefiniti delle notifiche email nei tuoi mailables. Poiché i messaggi sono scritti in Markdown, Laravel può generare template HTML belli e reattivi per i messaggi, creando automaticamente anche una versione in testo semplice.

Generare Mailables con Markdown

Per generare un mailable con un template Markdown corrispondente, puoi usare l’opzione --markdown del comando Artisan make:mail:

php artisan make:mail OrderShipped --markdown=mail.orders.shipped

Successivamente, quando configuri la definizione Content del mailable nel suo metodo content, usa il parametro markdown invece del parametro view:

use Illuminate\Mail\Mailables\Content;

/**
 * Ottieni la definizione del contenuto del messaggio.
 */
public function content(): Content
{
    return new Content(
        markdown: 'mail.orders.shipped',
        with: [
            'url' => $this->orderUrl,
        ],
    );
}

Scrivere Messaggi in Markdown

I Markdown mailables utilizzano una combinazione di componenti Blade e sintassi Markdown che ti permettono di costruire facilmente messaggi email sfruttando i componenti UI predefiniti di Laravel per le email:

<x-mail::message>
# Ordine Spedito

Il tuo ordine è stato spedito!

<x-mail::button :url="$url">
Visualizza Ordine
</x-mail::button>

Grazie,<br>
{{ config('app.name') }}
</x-mail::message>

Non usare indentazione eccessiva quando scrivi email in Markdown. Secondo gli standard di Markdown, i parser Markdown renderizzeranno il contenuto indentato come blocchi di codice.

Componente Pulsante

Il componente pulsante visualizza un link pulsante centrato. Il componente accetta due argomenti, un url e un color opzionale. I colori supportati sono primary, success ed error. Puoi aggiungere quanti componenti pulsante desideri a un messaggio:

<x-mail::button :url="$url" color="success">
View Order
</x-mail::button>

Panel Component

Il componente panel rende un blocco di testo all’interno di un pannello con un colore di sfondo leggermente diverso rispetto al resto del messaggio. Questo permette di evidenziare un determinato blocco di testo:

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

Componente Tabella

Il componente tabella consente di trasformare una tabella Markdown in una tabella HTML. Il componente accetta la tabella Markdown come contenuto. È supportato l’allineamento delle colonne utilizzando la sintassi predefinita di allineamento delle tabelle Markdown:

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

Personalizzare i Componenti

Puoi esportare tutti i componenti di email Markdown nella tua applicazione per personalizzarli. Per esportare i componenti, utilizza il comando Artisan vendor:publish per pubblicare il tag laravel-mail:

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

Questo comando pubblicherà i componenti di email Markdown nella directory resources/views/vendor/mail. La cartella mail conterrà una directory html e una text, ognuna con le rispettive versioni di ogni componente disponibile. Sei libero di personalizzare questi componenti come preferisci.

Personalizzazione del CSS

Dopo aver esportato i componenti, la directory resources/views/vendor/mail/html/themes conterrà un file default.css. Puoi personalizzare il CSS in questo file e i tuoi stili verranno automaticamente convertiti in stili CSS in linea nelle rappresentazioni HTML dei tuoi messaggi di posta Markdown.

Se desideri creare un tema completamente nuovo per i componenti Markdown di Laravel, puoi posizionare un file CSS nella directory html/themes. Dopo aver nominato e salvato il tuo file CSS, aggiorna l’opzione theme nel file di configurazione config/mail.php della tua applicazione per corrispondere al nome del tuo nuovo tema.

Per personalizzare il tema per un singolo mailable, puoi impostare la proprietà $theme della classe mailable al nome del tema che deve essere utilizzato quando invii quel mailable.

Invio delle email

Per inviare un messaggio, utilizza il metodo to sulla facade Mail. Il metodo to accetta un indirizzo email, un’istanza di utente o una collezione di utenti. Se passi un oggetto o una collezione di oggetti, il mailer utilizzerà automaticamente le proprietà email e name per determinare i destinatari dell’email, quindi assicurati che questi attributi siano disponibili nei tuoi oggetti. Una volta specificati i destinatari, puoi passare un’istanza della tua classe mailable al metodo send:

    <?php

    namespace App\Http\Controllers;

    use App\Http\Controllers\Controller;
    use App\Mail\OrderShipped;
    use App\Models\Order;
    use Illuminate\Http\RedirectResponse;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Mail;

    class OrderShipmentController extends Controller
    {
        /**
         * Spedisce l'ordine fornito.
         */
        public function store(Request $request): RedirectResponse
        {
            $order = Order::findOrFail($request->order_id);

            // Spedire l'ordine...

            Mail::to($request->user())->send(new OrderShipped($order));

            return redirect('/orders');
        }
    }

Non sei limitato a specificare solo i destinatari "to" quando invii un messaggio. Puoi impostare destinatari "to", "cc" e "bcc" concatenando i rispettivi metodi:

    Mail::to($request->user())
        ->cc($moreUsers)
        ->bcc($evenMoreUsers)
        ->send(new OrderShipped($order));

Ciclo sui Destinatari

A volte, potrebbe essere necessario inviare un mailable a una lista di destinatari iterando su un array di destinatari / indirizzi email. Tuttavia, poiché il metodo to aggiunge indirizzi email alla lista dei destinatari del mailable, ogni iterazione del ciclo invierà un’altra email a tutti i destinatari precedenti. Perciò, dovresti sempre ricreare l’istanza del mailable per ogni destinatario:

foreach (['taylor@example.com', 'dries@example.com'] as $recipient) {
    Mail::to($recipient)->send(new OrderShipped($order));
}

Inviare Email tramite un Mailer Specifico

Per impostazione predefinita, Laravel invia email utilizzando il mailer configurato come default nel file di configurazione mail della tua applicazione. Tuttavia, puoi usare il metodo mailer per inviare un messaggio utilizzando una configurazione mailer specifica:

Mail::mailer('postmark')
        ->to($request->user())
        ->send(new OrderShipped($order));

Invio delle email tramite coda

Inviare un Messaggio Email in Coda

Poiché l’invio di messaggi email può influire negativamente sul tempo di risposta della tua applicazione, molti sviluppatori scelgono di mettere in coda i messaggi email per l’invio in background. Laravel semplifica questo processo grazie alla sua API unificata per le code. Per mettere in coda un messaggio email, usa il metodo queue sulla facade Mail dopo aver specificato i destinatari del messaggio:

    Mail::to($request->user())
        ->cc($moreUsers)
        ->bcc($evenMoreUsers)
        ->queue(new OrderShipped($order));

Questo metodo si occuperà automaticamente di aggiungere un job alla coda in modo che il messaggio venga inviato in background. Dovrai configurare le tue code prima di utilizzare questa funzionalità.

Accodamento dei Messaggi Ritardati

Se desideri ritardare l’invio di un’email in coda, puoi usare il metodo later. Come primo argomento, il metodo later accetta un’istanza di DateTime che indica quando il messaggio dovrebbe essere inviato:

Mail::to($request->user())
    ->cc($moreUsers)
    ->bcc($evenMoreUsers)
    ->later(now()->addMinutes(10), new OrderShipped($order));

Invio a Code Specifiche

Poiché tutte le classi mailable generate con il comando make:mail utilizzano il trait Illuminate\Bus\Queueable, puoi chiamare i metodi onQueue e onConnection su qualsiasi istanza di classe mailable, permettendoti di specificare la connessione e il nome della coda per il messaggio:

$message = (new OrderShipped($order))
                ->onConnection('sqs')
                ->onQueue('emails');

Mail::to($request->user())
    ->cc($moreUsers)
    ->bcc($evenMoreUsers)
    ->queue($message);

Accodamento di Default

Se hai classi mailable che desideri siano sempre accodate, puoi implementare il contratto ShouldQueue sulla classe. Ora, anche se chiami il metodo send durante l’invio, il mailable sarà comunque accodato poiché implementa il contratto:

use Illuminate\Contracts\Queue\ShouldQueue;

class OrderShipped extends Mailable implements ShouldQueue
{
    // ...
}

Mailables in coda e Transazioni del database

Quando i mailables in coda vengono inviati all’interno di transazioni del database, potrebbero essere elaborati dalla coda prima che la transazione del database sia stata confermata. Quando ciò accade, eventuali aggiornamenti apportati ai modelli o ai record del database durante la transazione potrebbero non essere ancora riflessi nel database. Inoltre, qualsiasi modello o record del database creato all’interno della transazione potrebbe non esistere nel database. Se il tuo mailable dipende da questi modelli, potrebbero verificarsi errori inaspettati quando il job che invia il mailable in coda viene elaborato.

Se l’opzione di configurazione after_commit della tua connessione di coda è impostata su false, puoi comunque indicare che un particolare mailable in coda deve essere inviato dopo che tutte le transazioni aperte del database sono state confermate, chiamando il metodo afterCommit quando invii il messaggio di posta:

Mail::to($request->user())->send(
    (new OrderShipped($order))->afterCommit()
);

In alternativa, puoi chiamare il metodo afterCommit dal costruttore del tuo mailable:

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class OrderShipped extends Mailable implements ShouldQueue
{
    use Queueable, SerializesModels;

    /**
     * Crea una nuova istanza del messaggio.
     */
    public function __construct()
    {
        $this->afterCommit();
    }
}

Per saperne di più su come aggirare questi problemi, consulta la documentazione relativa a job in coda e transazioni del database.

Rendering Mailables

A volte potresti voler catturare il contenuto HTML di un mailable senza inviarlo. Per fare ciò, puoi chiamare il metodo render del mailable. Questo metodo restituirà il contenuto HTML valutato del mailable come stringa:

use App\Mail\InvoicePaid;
use App\Models\Invoice;

$invoice = Invoice::find(1);

return (new InvoicePaid($invoice))->render();

Anteprima delle Mailables nel Browser

Quando si progetta il template di una mailable, è conveniente poter visualizzare rapidamente la mailable renderizzata nel browser, come un normale template Blade. Per questo motivo, Laravel permette di restituire qualsiasi mailable direttamente da una closure di route o da un controller. Quando una mailable viene restituita, verrà renderizzata e mostrata nel browser, permettendoti di visualizzare velocemente il suo design senza doverla inviare a un indirizzo email effettivo:

    Route::get('/mailable', function () {
        $invoice = App\Models\Invoice::find(1);

        return new App\Mail\InvoicePaid($invoice);
    });

Localizzazione dei Mailables

Laravel ti permette di inviare mailables in una lingua diversa dalla locale attuale della richiesta e ricorderà anche questa locale se la mail è in coda.

Per fare questo, la facade Mail offre un metodo locale per impostare la lingua desiderata. L’applicazione passerà a questa locale quando il template del mailable verrà valutato e poi tornerà alla locale precedente una volta completata la valutazione:

    Mail::to($request->user())->locale('es')->send(
        new OrderShipped($order)
    );

Preferenze Locali dell’Utente

A volte, le applicazioni memorizzano la locale preferita di ogni utente. Implementando il contratto HasLocalePreference in uno o più dei tuoi modelli, puoi istruire Laravel a usare questa locale memorizzata quando invia email:

use Illuminate\Contracts\Translation\HasLocalePreference;

class User extends Model implements HasLocalePreference
{
    /**
     * Ottieni la locale preferita dall'utente.
     */
    public function preferredLocale(): string
    {
        return $this->locale;
    }
}

Una volta implementata l’interfaccia, Laravel utilizzerà automaticamente la locale preferita quando invia mailables e notifiche al modello. Pertanto, non è necessario chiamare il metodo locale quando si utilizza questa interfaccia:

Mail::to($request->user())->send(new OrderShipped($order));

Test

Testare il contenuto di Mailable

Laravel offre diversi metodi per ispezionare la struttura del tuo mailable. Inoltre, Laravel mette a disposizione vari metodi comodi per verificare che il tuo mailable contenga il contenuto che ti aspetti. Questi metodi sono: assertSeeInHtml, assertDontSeeInHtml, assertSeeInOrderInHtml, assertSeeInText, assertDontSeeInText, assertSeeInOrderInText, assertHasAttachment, assertHasAttachedData, assertHasAttachmentFromStorage, e assertHasAttachmentFromStorageDisk.

Come ci si può aspettare, le asserzioni "HTML" verificano che la versione HTML del tuo mailable contenga una certa stringa, mentre le asserzioni "text" verificano che la versione in testo semplice del tuo mailable contenga una certa stringa:

use App\Mail\InvoicePaid;
use App\Models\User;

test('mailable content', function () {
    $user = User::factory()->create();

    $mailable = new InvoicePaid($user);

    $mailable->assertFrom('jeffrey@example.com');
    $mailable->assertTo('taylor@example.com');
    $mailable->assertHasCc('abigail@example.com');
    $mailable->assertHasBcc('victoria@example.com');
    $mailable->assertHasReplyTo('tyler@example.com');
    $mailable->assertHasSubject('Invoice Paid');
    $mailable->assertHasTag('example-tag');
    $mailable->assertHasMetadata('key', 'value');

    $mailable->assertSeeInHtml($user->email);
    $mailable->assertSeeInHtml('Invoice Paid');
    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);

    $mailable->assertSeeInText($user->email);
    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);

    $mailable->assertHasAttachment('/path/to/file');
    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
});

use App\Mail\InvoicePaid;
use App\Models\User;

public function test_mailable_content(): void
{
    $user = User::factory()->create();

    $mailable = new InvoicePaid($user);

    $mailable->assertFrom('jeffrey@example.com');
    $mailable->assertTo('taylor@example.com');
    $mailable->assertHasCc('abigail@example.com');
    $mailable->assertHasBcc('victoria@example.com');
    $mailable->assertHasReplyTo('tyler@example.com');
    $mailable->assertHasSubject('Invoice Paid');
    $mailable->assertHasTag('example-tag');
    $mailable->assertHasMetadata('key', 'value');

    $mailable->assertSeeInHtml($user->email);
    $mailable->assertSeeInHtml('Invoice Paid');
    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);

    $mailable->assertSeeInText($user->email);
    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);

    $mailable->assertHasAttachment('/path/to/file');
    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
}

Testare l’Invio dei Mailable

Consigliamo di testare il contenuto dei tuoi mailable separatamente dai test che verificano che un determinato mailable sia stato "inviato" a un utente specifico. Generalmente, il contenuto dei mailable non è rilevante per il codice che stai testando, ed è sufficiente semplicemente verificare che Laravel sia stato istruito a inviare un determinato mailable.

Puoi usare il metodo fake della facciata Mail per impedire l’invio delle email. Dopo aver chiamato il metodo fake della facciata Mail, puoi quindi verificare che i mailable siano stati istruiti ad essere inviati agli utenti e persino ispezionare i dati ricevuti dai mailable:

<?php

use App\Mail\OrderShipped;
use Illuminate\Support\Facades\Mail;

test('orders can be shipped', function () {
    Mail::fake();

    // Esegui la spedizione dell'ordine...

    // Verifica che nessun mailable sia stato inviato...
    Mail::assertNothingSent();

    // Verifica che un mailable sia stato inviato...
    Mail::assertSent(OrderShipped::class);

    // Verifica che un mailable sia stato inviato due volte...
    Mail::assertSent(OrderShipped::class, 2);

    // Verifica che un mailable sia stato inviato a un indirizzo email...
    Mail::assertSent(OrderShipped::class, 'example@laravel.com');

    // Verifica che un mailable sia stato inviato a più indirizzi email...
    Mail::assertSent(OrderShipped::class, ['example@laravel.com', '...']);

    // Verifica che un mailable non sia stato inviato...
    Mail::assertNotSent(AnotherMailable::class);

    // Verifica che siano stati inviati 3 mailable in totale...
    Mail::assertSentCount(3);
});

<?php

namespace Tests\Feature;

use App\Mail\OrderShipped;
use Illuminate\Support\Facades\Mail;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_orders_can_be_shipped(): void
    {
        Mail::fake();

        // Esegui la spedizione dell'ordine...

        // Verifica che nessun mailable sia stato inviato...
        Mail::assertNothingSent();

        // Verifica che un mailable sia stato inviato...
        Mail::assertSent(OrderShipped::class);

        // Verifica che un mailable sia stato inviato due volte...
        Mail::assertSent(OrderShipped::class, 2);

        // Verifica che un mailable sia stato inviato a un indirizzo email...
        Mail::assertSent(OrderShipped::class, 'example@laravel.com');

        // Verifica che un mailable sia stato inviato a più indirizzi email...
        Mail::assertSent(OrderShipped::class, ['example@laravel.com', '...']);

        // Verifica che un mailable non sia stato inviato...
        Mail::assertNotSent(AnotherMailable::class);

        // Verifica che siano stati inviati 3 mailable in totale...
        Mail::assertSentCount(3);
    }
}

Se stai mettendo in coda i mailable per la consegna in background, dovresti usare il metodo assertQueued invece di assertSent:

    Mail::assertQueued(OrderShipped::class);
    Mail::assertNotQueued(OrderShipped::class);
    Mail::assertNothingQueued();
    Mail::assertQueuedCount(3);

Puoi passare una closure ai metodi assertSent, assertNotSent, assertQueued o assertNotQueued per verificare che un mailable sia stato inviato e superi un determinato "test di verità". Se almeno un mailable è stato inviato e supera il test di verità, l’asserzione avrà successo:

    Mail::assertSent(function (OrderShipped $mail) use ($order) {
        return $mail->order->id === $order->id;
    });

Quando chiami i metodi di asserzione della facciata Mail, l’istanza del mailable accettata dalla closure fornita espone metodi utili per esaminare il mailable:

    Mail::assertSent(OrderShipped::class, function (OrderShipped $mail) use ($user) {
        return $mail->hasTo($user->email) &&
               $mail->hasCc('...') &&
               $mail->hasBcc('...') &&
               $mail->hasReplyTo('...') &&
               $mail->hasFrom('...') &&
               $mail->hasSubject('...');
    });

L’istanza del mailable include anche diversi metodi utili per esaminare gli allegati di un mailable:

    use Illuminate\Mail\Mailables\Attachment;

    Mail::assertSent(OrderShipped::class, function (OrderShipped $mail) {
        return $mail->hasAttachment(
            Attachment::fromPath('/path/to/file')
                    ->as('name.pdf')
                    ->withMime('application/pdf')
        );
    });

    Mail::assertSent(OrderShipped::class, function (OrderShipped $mail) {
        return $mail->hasAttachment(
            Attachment::fromStorageDisk('s3', '/path/to/file')
        );
    });

    Mail::assertSent(OrderShipped::class, function (OrderShipped $mail) use ($pdfData) {
        return $mail->hasAttachment(
            Attachment::fromData(fn () => $pdfData, 'name.pdf')
        );
    });

Avrai notato che ci sono due metodi per asserire che una mail non è stata inviata: assertNotSent e assertNotQueued. A volte potresti voler verificare che nessuna mail sia stata inviata o messa in coda. Per fare ciò, puoi usare i metodi assertNothingOutgoing e assertNotOutgoing:

    Mail::assertNothingOutgoing();

    Mail::assertNotOutgoing(function (OrderShipped $mail) use ($order) {
        return $mail->order->id === $order->id;
    });

Mail e Sviluppo Locale

Durante lo sviluppo di un’applicazione che invia email, probabilmente non vorrai inviare effettivamente email a indirizzi reali. Laravel offre diversi modi per "disabilitare" l’invio effettivo delle email durante lo sviluppo locale.

Log Driver

Invece di inviare le email, il driver di posta log scriverà tutti i messaggi email nei tuoi file di log per la verifica. Tipicamente, questo driver viene utilizzato solo durante lo sviluppo locale. Per maggiori informazioni sulla configurazione della tua applicazione per ambiente, consulta la documentazione di configurazione.

HELO / Mailtrap / Mailpit

In alternativa, puoi usare un servizio come HELO o Mailtrap e il driver smtp per inviare i tuoi messaggi email a una casella di posta "fittizia" dove puoi visualizzarli in un vero client email. Questo approccio ti permette di ispezionare realmente le email finali nel visualizzatore di messaggi di Mailtrap.

Se stai usando Laravel Sail, puoi previsualizzare i tuoi messaggi usando Mailpit. Quando Sail è in esecuzione, puoi accedere all’interfaccia di Mailpit su: http://localhost:8025.

Utilizzo di un indirizzo to globale

Infine, puoi specificare un indirizzo "to" globale invocando il metodo alwaysTo offerto dalla facade Mail. Tipicamente, questo metodo dovrebbe essere chiamato dal metodo boot di uno dei service provider della tua applicazione:

use Illuminate\Support\Facades\Mail;

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    if ($this->app->environment('local')) {
        Mail::alwaysTo('taylor@example.com');
    }
}

Eventi

Laravel emette due eventi durante l’invio dei messaggi di posta. L’evento MessageSending viene emesso prima che un messaggio sia inviato, mentre l’evento MessageSent viene emesso dopo che un messaggio è stato inviato. Ricorda, questi eventi vengono emessi quando la posta viene inviata, non quando è in coda. Puoi creare listener di eventi per questi eventi all’interno della tua applicazione:

use Illuminate\Mail\Events\MessageSending;
// use Illuminate\Mail\Events\MessageSent;

class LogMessage
{
    /**
     * Gestisci l'evento dato.
     */
    public function handle(MessageSending $event): void
    {
        // ...
    }
}

Transport Personalizzati

Laravel include diversi transport per le email; tuttavia, potresti voler creare transport personalizzati per inviare email tramite altri servizi non supportati di default da Laravel. Per iniziare, definisci una classe che estende la classe Symfony\Component\Mailer\Transport\AbstractTransport. Poi, implementa i metodi doSend e __toString() nel tuo transport:

use MailchimpTransactional\ApiClient;
use Symfony\Component\Mailer\SentMessage;
use Symfony\Component\Mailer\Transport\AbstractTransport;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\MessageConverter;

class MailchimpTransport extends AbstractTransport
{
    /**
     * Crea una nuova istanza di transport Mailchimp.
     */
    public function __construct(
        protected ApiClient $client,
    ) {
        parent::__construct();
    }

    /**
     * {@inheritDoc}
     */
    protected function doSend(SentMessage $message): void
    {
        $email = MessageConverter::toEmail($message->getOriginalMessage());

        $this->client->messages->send(['message' => [
            'from_email' => $email->getFrom(),
            'to' => collect($email->getTo())->map(function (Address $email) {
                return ['email' => $email->getAddress(), 'type' => 'to'];
            })->all(),
            'subject' => $email->getSubject(),
            'text' => $email->getTextBody(),
        ]]);
    }

    /**
     * Ottiene la rappresentazione in stringa del transport.
     */
    public function __toString(): string
    {
        return 'mailchimp';
    }
}

Una volta definito il tuo transport personalizzato, puoi registrarlo tramite il metodo extend fornito dalla facade Mail. Solitamente, questo dovrebbe essere fatto all’interno del metodo boot del service provider AppServiceProvider della tua applicazione. Un argomento $config verrà passato alla chiusura fornita al metodo extend. Questo argomento conterrà l’array di configurazione definito per il mailer nel file di configurazione config/mail.php dell’applicazione:

use App\Mail\MailchimpTransport;
use Illuminate\Support\Facades\Mail;

/**
 * Avvia i servizi dell'applicazione.
 */
public function boot(): void
{
    Mail::extend('mailchimp', function (array $config = []) {
        return new MailchimpTransport(/* ... */);
    });
}

Una volta che il tuo transport personalizzato è stato definito e registrato, puoi creare una definizione di mailer nel file di configurazione config/mail.php della tua applicazione che utilizza il nuovo transport:

'mailchimp' => [
    'transport' => 'mailchimp',
    // ...
],

Transport Symfony Aggiuntivi

Laravel supporta già alcuni transport email di Symfony come Mailgun e Postmark. Tuttavia, potresti voler aggiungere altri transport mantenuti da Symfony. Puoi farlo installando il mailer Symfony necessario tramite Composer e registrando il transport in Laravel. Ad esempio, puoi installare e registrare il mailer Symfony "Brevo" (precedentemente "Sendinblue"):

composer require symfony/brevo-mailer symfony/http-client

Una volta installato il pacchetto del mailer Brevo, puoi aggiungere una voce per le tue credenziali API di Brevo nel file di configurazione services della tua applicazione:

    'brevo' => [
        'key' => 'your-api-key',
    ],

Successivamente, puoi usare il metodo extend della facade Mail per registrare il transport in Laravel. Di solito, questo va fatto nel metodo boot di un service provider:

    use Illuminate\Support\Facades\Mail;
    use Symfony\Component\Mailer\Bridge\Brevo\Transport\BrevoTransportFactory;
    use Symfony\Component\Mailer\Transport\Dsn;

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        Mail::extend('brevo', function () {
            return (new BrevoTransportFactory)->create(
                new Dsn(
                    'brevo+api',
                    'default',
                    config('services.brevo.key')
                )
            );
        });
    }

Dopo aver registrato il transport, puoi creare una definizione del mailer nel file di configurazione config/mail.php della tua applicazione che utilizza il nuovo transport:

    'brevo' => [
        'transport' => 'brevo',
        // ...
    ],
Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia