-
Notifications
You must be signed in to change notification settings - Fork 27
/
Mailer.php
executable file
·666 lines (586 loc) · 18.4 KB
/
Mailer.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
<?php
namespace Illuminate\Mail;
use Closure;
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\Mail\Mailables\Address;
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
* @param string|null $name
* @return \Illuminate\Mail\PendingMail
*/
public function to($users, $name = null)
{
if (! is_null($name) && is_string($users)) {
$users = new Address($users, $name);
}
return (new PendingMail($this))->to($users);
}
/**
* Begin the process of mailing a mailable class instance.
*
* @param mixed $users
* @param string|null $name
* @return \Illuminate\Mail\PendingMail
*/
public function cc($users, $name = null)
{
if (! is_null($name) && is_string($users)) {
$users = new Address($users, $name);
}
return (new PendingMail($this))->cc($users);
}
/**
* Begin the process of mailing a mailable class instance.
*
* @param mixed $users
* @param string|null $name
* @return \Illuminate\Mail\PendingMail
*/
public function bcc($users, $name = null)
{
if (! is_null($name) && is_string($users)) {
$users = new Address($users, $name);
}
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->replaceEmbeddedAttachments(
$this->renderView($view ?: $plain, $data),
$data['message']->getSymfonyMessage()->getAttachments()
);
}
/**
* Replace the embedded image attachments with raw, inline image data for browser rendering.
*
* @param string $renderedView
* @param array $attachments
* @return string
*/
protected function replaceEmbeddedAttachments(string $renderedView, array $attachments)
{
if (preg_match_all('/<img.+?src=[\'"]cid:([^\'"]+)[\'"].*?>/i', $renderedView, $matches)) {
foreach (array_unique($matches[1]) as $image) {
foreach ($attachments as $attachment) {
if ($attachment->getFilename() === $image) {
$renderedView = str_replace(
'cid:'.$image,
'data:'.$attachment->getContentType().';base64,'.$attachment->bodyToString(),
$renderedView
);
break;
}
}
}
}
return $renderedView;
}
/**
* 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);
}
$data['mailer'] = $this->name;
// 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.
[$view, $plain, $raw] = $this->parseView($view);
$data['message'] = $message = $this->createMessage();
$this->addContent($message, $view, $plain, $raw, $data);
if (! is_null($callback)) {
$callback($message);
}
// 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);
}
/**
* Send a new message synchronously using a view.
*
* @param \Illuminate\Contracts\Mail\Mailable|string|array $mailable
* @param array $data
* @param \Closure|string|null $callback
* @return \Illuminate\Mail\SentMessage|null
*/
public function sendNow($mailable, array $data = [], $callback = null)
{
return $mailable instanceof MailableContract
? $mailable->mailer($this->name)->send($this)
: $this->send($mailable, $data, $callback);
}
/**
* Parse the given view name or array.
*
* @param \Closure|array|string $view
* @return array
*
* @throws \InvalidArgumentException
*/
protected function parseView($view)
{
if (is_string($view) || $view instanceof Closure) {
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|null $view
* @param string|null $plain
* @param string|null $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 \Closure|string $view
* @param array $data
* @return string
*/
protected function renderView($view, $data)
{
$view = value($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 mail message for sending.
*
* @param \Illuminate\Contracts\Mail\Mailable|string|array $view
* @param \BackedEnum|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 mail message for sending on the given queue.
*
* @param \BackedEnum|string|null $queue
* @param \Illuminate\Contracts\Mail\Mailable $view
* @return mixed
*/
public function onQueue($queue, $view)
{
return $this->queue($view, $queue);
}
/**
* Queue a new 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 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 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 = [])
{
$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;
}
}