605 lines
16 KiB
PHP
605 lines
16 KiB
PHP
<?php
|
|
|
|
namespace Illuminate\Mail;
|
|
|
|
use Illuminate\Contracts\Events\Dispatcher;
|
|
use Illuminate\Contracts\Mail\Mailable as MailableContract;
|
|
use Illuminate\Contracts\Mail\Mailer as MailerContract;
|
|
use Illuminate\Contracts\Mail\MailQueue as MailQueueContract;
|
|
use Illuminate\Contracts\Queue\Factory as QueueContract;
|
|
use Illuminate\Contracts\Queue\ShouldQueue;
|
|
use Illuminate\Contracts\Support\Htmlable;
|
|
use Illuminate\Contracts\View\Factory;
|
|
use Illuminate\Mail\Events\MessageSending;
|
|
use Illuminate\Mail\Events\MessageSent;
|
|
use Illuminate\Support\HtmlString;
|
|
use Illuminate\Support\Traits\Macroable;
|
|
use InvalidArgumentException;
|
|
use Symfony\Component\Mailer\Envelope;
|
|
use Symfony\Component\Mailer\Transport\TransportInterface;
|
|
use Symfony\Component\Mime\Email;
|
|
|
|
class Mailer implements MailerContract, MailQueueContract
|
|
{
|
|
use Macroable;
|
|
|
|
/**
|
|
* The name that is configured for the mailer.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $name;
|
|
|
|
/**
|
|
* The view factory instance.
|
|
*
|
|
* @var \Illuminate\Contracts\View\Factory
|
|
*/
|
|
protected $views;
|
|
|
|
/**
|
|
* The Symfony Transport instance.
|
|
*
|
|
* @var \Symfony\Component\Mailer\Transport\TransportInterface
|
|
*/
|
|
protected $transport;
|
|
|
|
/**
|
|
* The event dispatcher instance.
|
|
*
|
|
* @var \Illuminate\Contracts\Events\Dispatcher|null
|
|
*/
|
|
protected $events;
|
|
|
|
/**
|
|
* The global from address and name.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $from;
|
|
|
|
/**
|
|
* The global reply-to address and name.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $replyTo;
|
|
|
|
/**
|
|
* The global return path address.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $returnPath;
|
|
|
|
/**
|
|
* The global to address and name.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $to;
|
|
|
|
/**
|
|
* The queue factory implementation.
|
|
*
|
|
* @var \Illuminate\Contracts\Queue\Factory
|
|
*/
|
|
protected $queue;
|
|
|
|
/**
|
|
* Create a new Mailer instance.
|
|
*
|
|
* @param string $name
|
|
* @param \Illuminate\Contracts\View\Factory $views
|
|
* @param \Symfony\Component\Mailer\Transport\TransportInterface $transport
|
|
* @param \Illuminate\Contracts\Events\Dispatcher|null $events
|
|
* @return void
|
|
*/
|
|
public function __construct(string $name, Factory $views, TransportInterface $transport, Dispatcher $events = null)
|
|
{
|
|
$this->name = $name;
|
|
$this->views = $views;
|
|
$this->events = $events;
|
|
$this->transport = $transport;
|
|
}
|
|
|
|
/**
|
|
* Set the global from address and name.
|
|
*
|
|
* @param string $address
|
|
* @param string|null $name
|
|
* @return void
|
|
*/
|
|
public function alwaysFrom($address, $name = null)
|
|
{
|
|
$this->from = compact('address', 'name');
|
|
}
|
|
|
|
/**
|
|
* Set the global reply-to address and name.
|
|
*
|
|
* @param string $address
|
|
* @param string|null $name
|
|
* @return void
|
|
*/
|
|
public function alwaysReplyTo($address, $name = null)
|
|
{
|
|
$this->replyTo = compact('address', 'name');
|
|
}
|
|
|
|
/**
|
|
* Set the global return path address.
|
|
*
|
|
* @param string $address
|
|
* @return void
|
|
*/
|
|
public function alwaysReturnPath($address)
|
|
{
|
|
$this->returnPath = compact('address');
|
|
}
|
|
|
|
/**
|
|
* Set the global to address and name.
|
|
*
|
|
* @param string $address
|
|
* @param string|null $name
|
|
* @return void
|
|
*/
|
|
public function alwaysTo($address, $name = null)
|
|
{
|
|
$this->to = compact('address', 'name');
|
|
}
|
|
|
|
/**
|
|
* Begin the process of mailing a mailable class instance.
|
|
*
|
|
* @param mixed $users
|
|
* @return \Illuminate\Mail\PendingMail
|
|
*/
|
|
public function to($users)
|
|
{
|
|
return (new PendingMail($this))->to($users);
|
|
}
|
|
|
|
/**
|
|
* Begin the process of mailing a mailable class instance.
|
|
*
|
|
* @param mixed $users
|
|
* @return \Illuminate\Mail\PendingMail
|
|
*/
|
|
public function cc($users)
|
|
{
|
|
return (new PendingMail($this))->cc($users);
|
|
}
|
|
|
|
/**
|
|
* Begin the process of mailing a mailable class instance.
|
|
*
|
|
* @param mixed $users
|
|
* @return \Illuminate\Mail\PendingMail
|
|
*/
|
|
public function bcc($users)
|
|
{
|
|
return (new PendingMail($this))->bcc($users);
|
|
}
|
|
|
|
/**
|
|
* Send a new message with only an HTML part.
|
|
*
|
|
* @param string $html
|
|
* @param mixed $callback
|
|
* @return \Illuminate\Mail\SentMessage|null
|
|
*/
|
|
public function html($html, $callback)
|
|
{
|
|
return $this->send(['html' => new HtmlString($html)], [], $callback);
|
|
}
|
|
|
|
/**
|
|
* Send a new message with only a raw text part.
|
|
*
|
|
* @param string $text
|
|
* @param mixed $callback
|
|
* @return \Illuminate\Mail\SentMessage|null
|
|
*/
|
|
public function raw($text, $callback)
|
|
{
|
|
return $this->send(['raw' => $text], [], $callback);
|
|
}
|
|
|
|
/**
|
|
* Send a new message with only a plain part.
|
|
*
|
|
* @param string $view
|
|
* @param array $data
|
|
* @param mixed $callback
|
|
* @return \Illuminate\Mail\SentMessage|null
|
|
*/
|
|
public function plain($view, array $data, $callback)
|
|
{
|
|
return $this->send(['text' => $view], $data, $callback);
|
|
}
|
|
|
|
/**
|
|
* Render the given message as a view.
|
|
*
|
|
* @param string|array $view
|
|
* @param array $data
|
|
* @return string
|
|
*/
|
|
public function render($view, array $data = [])
|
|
{
|
|
// First we need to parse the view, which could either be a string or an array
|
|
// containing both an HTML and plain text versions of the view which should
|
|
// be used when sending an e-mail. We will extract both of them out here.
|
|
[$view, $plain, $raw] = $this->parseView($view);
|
|
|
|
$data['message'] = $this->createMessage();
|
|
|
|
return $this->renderView($view ?: $plain, $data);
|
|
}
|
|
|
|
/**
|
|
* Send a new message using a view.
|
|
*
|
|
* @param \Illuminate\Contracts\Mail\Mailable|string|array $view
|
|
* @param array $data
|
|
* @param \Closure|string|null $callback
|
|
* @return \Illuminate\Mail\SentMessage|null
|
|
*/
|
|
public function send($view, array $data = [], $callback = null)
|
|
{
|
|
if ($view instanceof MailableContract) {
|
|
return $this->sendMailable($view);
|
|
}
|
|
|
|
// First we need to parse the view, which could either be a string or an array
|
|
// containing both an HTML and plain text versions of the view which should
|
|
// be used when sending an e-mail. We will extract both of them out here.
|
|
[$view, $plain, $raw] = $this->parseView($view);
|
|
|
|
$data['message'] = $message = $this->createMessage();
|
|
|
|
// Once we have retrieved the view content for the e-mail we will set the body
|
|
// of this message using the HTML type, which will provide a simple wrapper
|
|
// to creating view based emails that are able to receive arrays of data.
|
|
if (! is_null($callback)) {
|
|
$callback($message);
|
|
}
|
|
|
|
$this->addContent($message, $view, $plain, $raw, $data);
|
|
|
|
// If a global "to" address has been set, we will set that address on the mail
|
|
// message. This is primarily useful during local development in which each
|
|
// message should be delivered into a single mail address for inspection.
|
|
if (isset($this->to['address'])) {
|
|
$this->setGlobalToAndRemoveCcAndBcc($message);
|
|
}
|
|
|
|
// Next we will determine if the message should be sent. We give the developer
|
|
// one final chance to stop this message and then we will send it to all of
|
|
// its recipients. We will then fire the sent event for the sent message.
|
|
$symfonyMessage = $message->getSymfonyMessage();
|
|
|
|
if ($this->shouldSendMessage($symfonyMessage, $data)) {
|
|
$symfonySentMessage = $this->sendSymfonyMessage($symfonyMessage);
|
|
|
|
if ($symfonySentMessage) {
|
|
$sentMessage = new SentMessage($symfonySentMessage);
|
|
|
|
$this->dispatchSentEvent($sentMessage, $data);
|
|
|
|
return $sentMessage;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send the given mailable.
|
|
*
|
|
* @param \Illuminate\Contracts\Mail\Mailable $mailable
|
|
* @return \Illuminate\Mail\SentMessage|null
|
|
*/
|
|
protected function sendMailable(MailableContract $mailable)
|
|
{
|
|
return $mailable instanceof ShouldQueue
|
|
? $mailable->mailer($this->name)->queue($this->queue)
|
|
: $mailable->mailer($this->name)->send($this);
|
|
}
|
|
|
|
/**
|
|
* Parse the given view name or array.
|
|
*
|
|
* @param string|array $view
|
|
* @return array
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
protected function parseView($view)
|
|
{
|
|
if (is_string($view)) {
|
|
return [$view, null, null];
|
|
}
|
|
|
|
// If the given view is an array with numeric keys, we will just assume that
|
|
// both a "pretty" and "plain" view were provided, so we will return this
|
|
// array as is, since it should contain both views with numerical keys.
|
|
if (is_array($view) && isset($view[0])) {
|
|
return [$view[0], $view[1], null];
|
|
}
|
|
|
|
// If this view is an array but doesn't contain numeric keys, we will assume
|
|
// the views are being explicitly specified and will extract them via the
|
|
// named keys instead, allowing the developers to use one or the other.
|
|
if (is_array($view)) {
|
|
return [
|
|
$view['html'] ?? null,
|
|
$view['text'] ?? null,
|
|
$view['raw'] ?? null,
|
|
];
|
|
}
|
|
|
|
throw new InvalidArgumentException('Invalid view.');
|
|
}
|
|
|
|
/**
|
|
* Add the content to a given message.
|
|
*
|
|
* @param \Illuminate\Mail\Message $message
|
|
* @param string $view
|
|
* @param string $plain
|
|
* @param string $raw
|
|
* @param array $data
|
|
* @return void
|
|
*/
|
|
protected function addContent($message, $view, $plain, $raw, $data)
|
|
{
|
|
if (isset($view)) {
|
|
$message->html($this->renderView($view, $data) ?: ' ');
|
|
}
|
|
|
|
if (isset($plain)) {
|
|
$message->text($this->renderView($plain, $data) ?: ' ');
|
|
}
|
|
|
|
if (isset($raw)) {
|
|
$message->text($raw);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Render the given view.
|
|
*
|
|
* @param string $view
|
|
* @param array $data
|
|
* @return string
|
|
*/
|
|
protected function renderView($view, $data)
|
|
{
|
|
return $view instanceof Htmlable
|
|
? $view->toHtml()
|
|
: $this->views->make($view, $data)->render();
|
|
}
|
|
|
|
/**
|
|
* Set the global "to" address on the given message.
|
|
*
|
|
* @param \Illuminate\Mail\Message $message
|
|
* @return void
|
|
*/
|
|
protected function setGlobalToAndRemoveCcAndBcc($message)
|
|
{
|
|
$message->forgetTo();
|
|
|
|
$message->to($this->to['address'], $this->to['name'], true);
|
|
|
|
$message->forgetCc();
|
|
$message->forgetBcc();
|
|
}
|
|
|
|
/**
|
|
* Queue a new e-mail message for sending.
|
|
*
|
|
* @param \Illuminate\Contracts\Mail\Mailable|string|array $view
|
|
* @param string|null $queue
|
|
* @return mixed
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
public function queue($view, $queue = null)
|
|
{
|
|
if (! $view instanceof MailableContract) {
|
|
throw new InvalidArgumentException('Only mailables may be queued.');
|
|
}
|
|
|
|
if (is_string($queue)) {
|
|
$view->onQueue($queue);
|
|
}
|
|
|
|
return $view->mailer($this->name)->queue($this->queue);
|
|
}
|
|
|
|
/**
|
|
* Queue a new e-mail message for sending on the given queue.
|
|
*
|
|
* @param string $queue
|
|
* @param \Illuminate\Contracts\Mail\Mailable $view
|
|
* @return mixed
|
|
*/
|
|
public function onQueue($queue, $view)
|
|
{
|
|
return $this->queue($view, $queue);
|
|
}
|
|
|
|
/**
|
|
* Queue a new e-mail message for sending on the given queue.
|
|
*
|
|
* This method didn't match rest of framework's "onQueue" phrasing. Added "onQueue".
|
|
*
|
|
* @param string $queue
|
|
* @param \Illuminate\Contracts\Mail\Mailable $view
|
|
* @return mixed
|
|
*/
|
|
public function queueOn($queue, $view)
|
|
{
|
|
return $this->onQueue($queue, $view);
|
|
}
|
|
|
|
/**
|
|
* Queue a new e-mail message for sending after (n) seconds.
|
|
*
|
|
* @param \DateTimeInterface|\DateInterval|int $delay
|
|
* @param \Illuminate\Contracts\Mail\Mailable $view
|
|
* @param string|null $queue
|
|
* @return mixed
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
public function later($delay, $view, $queue = null)
|
|
{
|
|
if (! $view instanceof MailableContract) {
|
|
throw new InvalidArgumentException('Only mailables may be queued.');
|
|
}
|
|
|
|
return $view->mailer($this->name)->later(
|
|
$delay, is_null($queue) ? $this->queue : $queue
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Queue a new e-mail message for sending after (n) seconds on the given queue.
|
|
*
|
|
* @param string $queue
|
|
* @param \DateTimeInterface|\DateInterval|int $delay
|
|
* @param \Illuminate\Contracts\Mail\Mailable $view
|
|
* @return mixed
|
|
*/
|
|
public function laterOn($queue, $delay, $view)
|
|
{
|
|
return $this->later($delay, $view, $queue);
|
|
}
|
|
|
|
/**
|
|
* Create a new message instance.
|
|
*
|
|
* @return \Illuminate\Mail\Message
|
|
*/
|
|
protected function createMessage()
|
|
{
|
|
$message = new Message(new Email());
|
|
|
|
// If a global from address has been specified we will set it on every message
|
|
// instance so the developer does not have to repeat themselves every time
|
|
// they create a new message. We'll just go ahead and push this address.
|
|
if (! empty($this->from['address'])) {
|
|
$message->from($this->from['address'], $this->from['name']);
|
|
}
|
|
|
|
// When a global reply address was specified we will set this on every message
|
|
// instance so the developer does not have to repeat themselves every time
|
|
// they create a new message. We will just go ahead and push this address.
|
|
if (! empty($this->replyTo['address'])) {
|
|
$message->replyTo($this->replyTo['address'], $this->replyTo['name']);
|
|
}
|
|
|
|
if (! empty($this->returnPath['address'])) {
|
|
$message->returnPath($this->returnPath['address']);
|
|
}
|
|
|
|
return $message;
|
|
}
|
|
|
|
/**
|
|
* Send a Symfony Email instance.
|
|
*
|
|
* @param \Symfony\Component\Mime\Email $message
|
|
* @return \Symfony\Component\Mailer\SentMessage|null
|
|
*/
|
|
protected function sendSymfonyMessage(Email $message)
|
|
{
|
|
try {
|
|
return $this->transport->send($message, Envelope::create($message));
|
|
} finally {
|
|
//
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if the email can be sent.
|
|
*
|
|
* @param \Symfony\Component\Mime\Email $message
|
|
* @param array $data
|
|
* @return bool
|
|
*/
|
|
protected function shouldSendMessage($message, $data = [])
|
|
{
|
|
if (! $this->events) {
|
|
return true;
|
|
}
|
|
|
|
return $this->events->until(
|
|
new MessageSending($message, $data)
|
|
) !== false;
|
|
}
|
|
|
|
/**
|
|
* Dispatch the message sent event.
|
|
*
|
|
* @param \Illuminate\Mail\SentMessage $message
|
|
* @param array $data
|
|
* @return void
|
|
*/
|
|
protected function dispatchSentEvent($message, $data = [])
|
|
{
|
|
if ($this->events) {
|
|
$this->events->dispatch(
|
|
new MessageSent($message, $data)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the Symfony Transport instance.
|
|
*
|
|
* @return \Symfony\Component\Mailer\Transport\TransportInterface
|
|
*/
|
|
public function getSymfonyTransport()
|
|
{
|
|
return $this->transport;
|
|
}
|
|
|
|
/**
|
|
* Get the view factory instance.
|
|
*
|
|
* @return \Illuminate\Contracts\View\Factory
|
|
*/
|
|
public function getViewFactory()
|
|
{
|
|
return $this->views;
|
|
}
|
|
|
|
/**
|
|
* Set the Symfony Transport instance.
|
|
*
|
|
* @param \Symfony\Component\Mailer\Transport\TransportInterface $transport
|
|
* @return void
|
|
*/
|
|
public function setSymfonyTransport(TransportInterface $transport)
|
|
{
|
|
$this->transport = $transport;
|
|
}
|
|
|
|
/**
|
|
* Set the queue manager instance.
|
|
*
|
|
* @param \Illuminate\Contracts\Queue\Factory $queue
|
|
* @return $this
|
|
*/
|
|
public function setQueue(QueueContract $queue)
|
|
{
|
|
$this->queue = $queue;
|
|
|
|
return $this;
|
|
}
|
|
}
|