MailTemplateService.php 21.6 KB
Newer Older
1
2
3
4
<?php

namespace SGalinski\SgMail\Service;

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/***************************************************************
 *  Copyright notice
 *
 *  (c) sgalinski Internet Services (https://www.sgalinski.de)
 *
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/
28

29
use DateTime;
30
31
32
use SGalinski\SgMail\Domain\Model\Mail;
use SGalinski\SgMail\Domain\Model\Template;
use SGalinski\SgMail\Domain\Repository\MailRepository;
33
use SGalinski\SgMail\Domain\Repository\TemplateRepository;
34
35
use Swift_Attachment;
use Swift_OutputByteStream;
36
use TYPO3\CMS\Core\Mail\MailMessage;
37
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
38
39
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Object\ObjectManager;
40
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
41
use TYPO3\CMS\Extbase\Utility\LocalizationUtility;
42
use TYPO3\CMS\Fluid\View\StandaloneView;
43
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
44

45
46
47
/**
 * MailTemplateService
 */
48
class MailTemplateService {
49
	const MARKER_TYPE_STRING = 'String';
50
51
	const MARKER_TYPE_ARRAY = 'Array';
	const MARKER_TYPE_OBJECT = 'Object';
52
	const DEFAULT_LANGUAGE = 'default';
53

54
	/**
55
	 * @var array $registerArray
56
	 */
57
	private static $registerArray = [];
58

59
	/**
60
	 * @var array $toAddresses
61
	 */
62
	private $toAddresses = [];
63
64

	/**
65
	 * @var string $fromAddress
66
	 */
67
	private $fromAddress;
68
69

	/**
70
	 * @var array $ccAddresses
71
	 */
Paul Ilea's avatar
Paul Ilea committed
72
	private $ccAddresses;
73
74

	/**
75
	 * @var string $replyToAddress
76
	 */
77
	private $replyToAddress;
78
79

	/**
80
	 * @var string $language
81
	 */
82
	private $language;
83
84

	/**
85
	 * @var boolean $ignoreMailQueue
86
	 */
87
	private $ignoreMailQueue = FALSE;
88
89
90
91
92
93
94

	/**
	 * @var \TYPO3\CMS\Core\Mail\MailMessage $mailMessage
	 */
	private $mailMessage;

	/**
95
	 * @var string $templateName
96
97
98
99
	 */
	private $templateName;

	/**
100
	 * @var string $extensionKey
101
102
103
104
	 */
	private $extensionKey;

	/**
105
	 * @var array $markers
106
	 */
107
	private $markers = [];
108

109
110
111
	/**
	 * holds the TypoScript configuration for sg_mail
	 *
112
	 * @var array $tsSettings
113
	 */
Paul Ilea's avatar
Paul Ilea committed
114
	private $tsSettings;
115

116
117
118
	/**
	 * @var array $bccAddresses
	 */
Paul Ilea's avatar
Paul Ilea committed
119
	private $bccAddresses;
120

121
122
123
124
125
	/**
	 * @var int
	 */
	private $priority = Mail::PRIORITY_LOWEST;

126
127
128
129
130
	/**
	 * @var int
	 */
	private $pid;

131
132
133
134
135
	/**
	 * @var string
	 */
	private $fromName = '';

136
137
138
	/**
	 * @var \SGalinski\SgMail\Domain\Repository\TemplateRepository
	 */
139
140
141
142
143
144
	protected $templateRepository;

	/**
	 * @var \TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager
	 */
	protected $persistenceManager;
145

146
147
148
149
150
	/**
	 * @var \TYPO3\CMS\Extbase\Object\ObjectManager
	 */
	protected $objectManager;

151
152
	/**
	 * MailTemplateService constructor.
Paul Ilea's avatar
Paul Ilea committed
153
	 *
154
155
156
	 * @param string $templateName
	 * @param string $extensionKey
	 * @param string $markers
Paul Ilea's avatar
Paul Ilea committed
157
	 * @throws \InvalidArgumentException
158
	 */
159
160
161
162
163
	public function __construct($templateName = '', $extensionKey = '', $markers = '') {
		$this->templateName = $templateName;
		$this->extensionKey = $extensionKey;
		$this->markers = $markers;

164
165
166
167
168
169
		/** @var ObjectManager objectManager */
		$this->objectManager = GeneralUtility::makeInstance(ObjectManager::class);
		/** @var MailMessage mailMessage */
		$this->mailMessage = $this->objectManager->get(MailMessage::class);
		/** @var TypoScriptSettingsService $typoScriptSettingsService */
		$typoScriptSettingsService = $this->objectManager->get(TypoScriptSettingsService::class);
170
171
		$this->tsSettings = $typoScriptSettingsService->getSettings(0, 'tx_sgmail');
		$this->language = $this->tsSettings['templateDefaultLanguage'];
172
173
174
175
		/** @var TemplateRepository templateRepository */
		$this->templateRepository = $this->objectManager->get(TemplateRepository::class);
		/** @var PersistenceManager persistenceManager */
		$this->persistenceManager = $this->objectManager->get(PersistenceManager::class);
176

177
		// use defaultMailFromAddress if it is provided in LocalConfiguration.php; use the sg_mail TS setting as fallback
178
		if (!filter_var($GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'], FILTER_VALIDATE_EMAIL)) {
179
180
181
			$this->fromAddress = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'];
		} else {
			$this->fromAddress = $this->tsSettings['mail']['default']['from'];
182
183
184
185
186
187

			if (!filter_var($this->tsSettings['mail']['default']['from'], FILTER_VALIDATE_EMAIL)) {
				$this->fromAddress = 'noreply@example.org';
			} else {
				$this->fromAddress = $this->tsSettings['mail']['default']['from'];
			}
188
189
		}

190
		$this->mailMessage->setFrom($this->fromAddress);
191

192
		$this->bccAddresses = GeneralUtility::trimExplode(',', $this->tsSettings['mail']['default']['bcc']);
193
194
195
196
197
198
199
200
201
202
203
204
205
206
		$this->ccAddresses = GeneralUtility::trimExplode(',', $this->tsSettings['mail']['default']['cc']);

		foreach ($this->bccAddresses as $index => $email) {
			if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
				unset($this->bccAddresses[$index]);
			}
		}

		foreach ($this->ccAddresses as $index => $email) {
			if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
				unset($this->ccAddresses[$index]);
			}
		}

207
		if (count($this->bccAddresses) > 0) {
208
209
210
			$this->mailMessage->setBcc($this->bccAddresses);
		}

211
		if (count($this->ccAddresses) > 0) {
212
213
			$this->mailMessage->setCc($this->ccAddresses);
		}
214
215
	}

Torsten Oppermann's avatar
Torsten Oppermann committed
216
	/**
Torsten Oppermann's avatar
Torsten Oppermann committed
217
	 * register a template with sg_mail
Fabian Galinski's avatar
Fabian Galinski committed
218
	 *
219
220
221
	 * description and subject can now be an array i.e. with elements such as 'en' => 'english description'
	 * or an translation string used in locallang.xml
	 *
222
	 * @deprecated public usage of this function is deprecated. use registerByFile instead
223
	 * @param string $extension
Torsten Oppermann's avatar
Torsten Oppermann committed
224
225
	 * @param string $templateName
	 * @param string $templatePath
226
	 * @param mixed $description
227
	 * @param array $markers
228
	 * @param mixed $subject
229
	 * @param string $usage
Torsten Oppermann's avatar
Torsten Oppermann committed
230
	 */
231
	public static function registerTemplate(
232
		$extension, $templateName, $templatePath, $description, array $markers, $subject, $usage = ''
233
	) {
234
		MailTemplateService::$registerArray[$extension][$templateName] = [
235
			'templatePath' => $templatePath,
236
			'description' => $description,
237
			'marker' => $markers,
238
			'extension' => $extension,
239
			'templateName' => $templateName,
240
241
			'subject' => $subject,
			'usage' => $usage
242
243
		];
	}
244

245
246
247
	/**
	 * call in extlocalconf of an extension if you have a custom register class
	 *
Paul Ilea's avatar
Paul Ilea committed
248
249
	 * @param RegisterInterface $fileNameWithNamespace
	 * @param boolean $initObject Should the object initialize itself ?
250
251
	 *
	 * @return bool
Paul Ilea's avatar
Paul Ilea committed
252
	 * @throws \InvalidArgumentException
253
	 */
254
	public static function registerByFile($fileNameWithNamespace, $initObject = TRUE) {
255
256
257
258
259
260
		$registerObject = GeneralUtility::makeInstance($fileNameWithNamespace);
		// check instance of interface
		if (!($registerObject instanceof RegisterInterface)) {
			return FALSE;
		}

261
262
263
264
		// object calls registerTemplate, alternative way instead of localconf call
		if ($initObject) {
			$registerObject->init();
		}
265
266
267
268
		$registerObject->registerTemplate();
		return TRUE;
	}

269
270
271
272
273
274
275
276
277
	/**
	 * Return default markers for sg_mail
	 *
	 * @param string $translationKey
	 * @param array $marker
	 * @param string $extensionKey
	 * @return array
	 */
	public static function getDefaultTemplateMarker($translationKey, array $marker, $extensionKey = 'sg_mail') {
278
		$languagePath = 'LLL:EXT:' . $extensionKey . '/Resources/Private/Language/locallang.xlf:' . $translationKey;
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298

		// Need the key for translations
		if (trim($extensionKey) === '') {
			return [];
		}

		$generatedMarker = [];
		foreach ($marker as $markerName) {
			$generatedMarker[] = [
				'marker' => $markerName,
				'value' => $languagePath . '.example.' . $markerName,
				'description' => $languagePath . '.description.' . $markerName,
				'backend_translation_key' => $translationKey . '.example.' . $markerName,
				'extension_key' => $extensionKey
			];
		}

		return $generatedMarker;
	}

299
	/**
Torsten Oppermann's avatar
Torsten Oppermann committed
300
	 * Get all registered templates
Fabian Galinski's avatar
Fabian Galinski committed
301
	 *
302
	 * @return array
303
	 */
304
305
	public static function getRegisterArray() {
		return self::$registerArray;
306
	}
307
308

	/**
309
	 * Send the Email
310
	 *
Torsten Oppermann's avatar
Torsten Oppermann committed
311
	 * @param boolean $isPreview
312
	 * @return boolean email was sent or added to mail queue successfully?
313
	 * @throws \TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException
314
	 */
315
	public function sendEmail($isPreview = FALSE) {
316
317
318
319
320
321
322
323
		if (TYPO3_MODE === 'FE') {
			/** @var TypoScriptFrontendController $tsfe */
			$tsfe = $GLOBALS['TSFE'];
			$pageUid = $tsfe->id;
		} else {
			$pageUid = (int) GeneralUtility::_GP('id');
		}

324
		$siteRootId = BackendService::getSiteRoot($pageUid);
325

326
		/** @var Template $template */
327
		$template = $this->templateRepository->findOneByTemplate(
328
			$this->extensionKey, $this->templateName, $this->language, $siteRootId
329
		);
330

331
332
333
334
335
		// if there is a template, prefer those values
		if ($template) {
			$this->loadTemplateValues($template);
		}

336
337
		// If there is no template for this language, use the default template
		if ($template === NULL) {
338

339
340
341
342
343
			$templatePath = self::$registerArray[$this->extensionKey][$this->templateName]['templatePath'];
			$templateFile = $templatePath . $this->language . '.template.html';
			if (file_exists($templateFile)) {
				$defaultTemplateContent = file_get_contents($templatePath . $this->language . '.template.html');
			} else {
344
				$defaultTemplateFile = $templatePath . 'template.html';
345

346
347
348
349
350
				if (file_exists($defaultTemplateFile)) {
					$defaultTemplateContent = file_get_contents($defaultTemplateFile);
				} else {
					return FALSE;
				}
351
			}
352
353
		}

Torsten Oppermann's avatar
Torsten Oppermann committed
354
355
		if ($isPreview) {
			$previewMarker = [];
Paul Ilea's avatar
Paul Ilea committed
356
			/** @var array $markerArray */
Torsten Oppermann's avatar
Torsten Oppermann committed
357
358
			$markerArray = self::$registerArray[$this->extensionKey][$this->templateName]['marker'];
			foreach ($markerArray as $marker) {
359
360
361
362
363
364
365
366
367
368
369
370
				$markerPath = GeneralUtility::trimExplode('.', $marker['marker']);
				$temporaryMarkerArray = [];
				foreach (array_reverse($markerPath) as $index => $markerPathSegment) {
					if ($index === 0) {
						if ($marker['backend_translation_key']) {
							$temporaryMarkerArray[$markerPathSegment] = LocalizationUtility::translate(
								$marker['backend_translation_key'], $marker['extension_key']
							);
						} else {
							$temporaryMarkerArray[$markerPathSegment] = $marker['value'];
						}
					} else {
371
						$temporaryMarkerArray = [$markerPathSegment => $temporaryMarkerArray];
372
					}
373
				}
374
				$previewMarker = array_merge_recursive($previewMarker, $temporaryMarkerArray);
Torsten Oppermann's avatar
Torsten Oppermann committed
375
			}
376
			$this->setIgnoreMailQueue(TRUE);
Torsten Oppermann's avatar
Torsten Oppermann committed
377
378
379
			$this->setMarkers($previewMarker);
		}

380
		/** @var StandaloneView $emailView */
381
		$emailView = $this->objectManager->get(StandaloneView::class);
382

383
		if (NULL === $defaultTemplateContent) {
384
			$emailView->setTemplateSource($template->getContent());
385
			$subject = $template->getSubject();
386
387
		} else {
			$emailView->setTemplateSource($defaultTemplateContent);
388
389
390
391
392
393
394
395
396
397

			$subject = self::$registerArray[$this->extensionKey][$this->templateName]['subject'];
			if (is_array($subject)) {
				$subject = self::$registerArray[$this->extensionKey][$this->templateName]['subject'][$this->language];
			} else {
				$subject = LocalizationUtility::translate(
					self::$registerArray[$this->extensionKey][$this->templateName]['subject'],
					$this->extensionKey
				);
			}
398
		}
399
		$this->mailMessage->setSubject($subject);
400

401
		$emailView->assignMultiple($this->markers);
402
		$emailBody = $emailView->render();
403

404
405
406
407
		// insert <br /> tags, but replace every instance of three or more successive breaks with just two.
		$emailBody = nl2br($emailBody);
		$emailBody = preg_replace('/(<br[\s]?[\/]?>[\s]*){3,}/', '<br /><br />', $emailBody);
		if ($this->ignoreMailQueue) {
408

409
			$this->mailMessage->setBody($emailBody, 'text/html');
410
			$this->mailMessage->send();
411
			$dateTime = new DateTime();
412
			$currentTimestamp = $dateTime->getTimestamp();
413
414
415
416

			if (!$isPreview) {
				$this->addMailToMailQueue(
					$this->extensionKey, $this->templateName, $subject, $emailBody, $this->priority,
417
					$currentTimestamp, $currentTimestamp, $this->language, $siteRootId
418
419
				);
			}
420

421
		} else {
422
423
			if (!$isPreview) {
				$this->addMailToMailQueue(
424
					$this->extensionKey, $this->templateName, $subject, $emailBody, $this->priority, 0, 0,
425
426
427
					$this->language, $siteRootId
				);
			}
428
		}
429
430

		return TRUE;
431
432
433
	}

	/**
434
	 * Adds a new mail to the mail queue.
435
	 *
436
437
	 * @param string $extensionKey
	 * @param string $templateName
438
	 * @param string $subject
439
	 * @param string $emailBody
440
	 * @param int $sendingTime
441
	 * @param int $priority
442
	 * @param int $lastSendingTime
443
	 * @param string $language
444
	 * @param int $pid
Paul Ilea's avatar
Paul Ilea committed
445
	 * @throws \TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException
446
	 */
447
	private function addMailToMailQueue(
448
		$extensionKey, $templateName, $subject, $emailBody, $priority, $sendingTime = 0,
449
		$lastSendingTime = 0, $language = self::DEFAULT_LANGUAGE, $pid = 0
450
	) {
451
		$mail = $this->objectManager->get(Mail::class);
452
		$mail->setPid($pid);
453
454
		$mail->setExtensionKey($extensionKey);
		$mail->setTemplateName($templateName);
455
		$mail->setLanguage($language);
456

457
		$mail->setFromAddress($this->fromAddress);
458
		$mail->setFromName($this->fromName);
459

460
		$mail->setToAddress($this->toAddresses);
461
		$mail->setMailSubject($subject);
462
		$mail->setMailBody($emailBody);
463
		$mail->setPriority($priority);
464
465
		$mail->setBccAddresses($this->bccAddresses);
		$mail->setCcAddresses($this->ccAddresses);
466
		$mail->setSendingTime($sendingTime);
467
		$mail->setLastSendingTime($lastSendingTime);
468
		$mail->setReplyTo($this->replyToAddress);
469

470
		$mailRepository = $this->objectManager->get(MailRepository::class);
471
		$mailRepository->add($mail);
472
		$this->persistenceManager->persistAll();
473
	}
474

475
476
477
478
	/**
	 * Send a Mail from the queue, identified by its id
	 *
	 * @param int $uid
Paul Ilea's avatar
Paul Ilea committed
479
480
	 * @throws \TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException
	 * @throws \TYPO3\CMS\Extbase\Persistence\Exception\UnknownObjectException
481
482
483
484
	 */
	public function sendMailFromQueue($uid) {
		$mailRepository = $this->objectManager->get(MailRepository::class);
		/** @var Mail $mailToSend */
485
		$mailToSend = $mailRepository->findOneByUid($uid);
486
487
488
489
490
491

		if ($mailToSend) {
			$this->mailMessage->setBody($mailToSend->getMailBody(), 'text/html');
			$this->mailMessage->setTo($mailToSend->getToAddress());
			$this->mailMessage->setFrom($mailToSend->getFromAddress(), $mailToSend->getFromName());
			$this->mailMessage->setSubject($mailToSend->getMailSubject());
492

493
			if ($mailToSend->getBccAddresses()) {
494
495
496
				$this->mailMessage->setBcc(GeneralUtility::trimExplode(',', $mailToSend->getBccAddresses()));
			}

497
			if ($mailToSend->getCcAddresses()) {
498
499
500
501
502
503
504
				$this->mailMessage->setCc(GeneralUtility::trimExplode(',', $mailToSend->getCcAddresses()));
			}

			if ($mailToSend->getReplyTo()) {
				$this->mailMessage->setReplyTo($mailToSend->getReplyTo());
			}

505
506
			$dateTime = new DateTime();
			$mailToSend->setLastSendingTime($dateTime->getTimestamp());
507
			$this->mailMessage->send();
508
			$mailRepository->update($mailToSend);
509
510
511
		}
	}

512
513
	/**
	 * @param array $registerArray
514
	 * @return void
515
	 */
516
	public static function setRegisterArray(array $registerArray) {
517
518
519
520
		self::$registerArray = $registerArray;
	}

	/**
521
	 * @param string $toAddresses
522
523
	 * @return MailTemplateService
	 */
524
525
526
	public function setToAddresses($toAddresses) {
		$this->toAddresses = $toAddresses;
		$this->mailMessage->setTo($toAddresses);
527
528
529
530
		return $this;
	}

	/**
531
	 * @param string $fromAddress
532
	 * @param string $fromName
533
534
	 * @return MailTemplateService
	 */
535
	public function setFromAddress($fromAddress, $fromName = '') {
536
537
538
539
540
		if ($fromAddress) {
			$this->fromAddress = $fromAddress;
			$this->mailMessage->setFrom($fromAddress, $fromName);
		}

541
542
543
544
		return $this;
	}

	/**
545
	 * @param string $ccAddresses
546
547
	 * @return MailTemplateService
	 */
548
	public function setCcAddresses($ccAddresses) {
549
550
		if ($ccAddresses) {
			$this->ccAddresses = $ccAddresses;
551
			$this->mailMessage->setCc(GeneralUtility::trimExplode(',', $this->ccAddresses));
552
553
		}

554
555
556
557
		return $this;
	}

	/**
558
	 * @param string $replyToAddress
559
560
	 * @return MailTemplateService
	 */
561
	public function setReplyToAddress($replyToAddress) {
562
563
564
565
566
		if ($replyToAddress) {
			$this->replyToAddress = $replyToAddress;
			$this->mailMessage->setReplyTo($replyToAddress);
		}

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
		return $this;
	}

	/**
	 * @param string $language
	 * @return MailTemplateService
	 */
	public function setLanguage($language) {
		$this->language = $language;
		return $this;
	}

	/**
	 * @param boolean $ignoreMailQueue
	 * @return MailTemplateService
	 */
	public function setIgnoreMailQueue($ignoreMailQueue) {
		$this->ignoreMailQueue = $ignoreMailQueue;
		return $this;
	}

	/**
	 * @param string $templateName
	 * @return MailTemplateService
	 */
	public function setTemplateName($templateName) {
		$this->templateName = $templateName;
		return $this;
	}

	/**
	 * @param string $extensionKey
	 * @return MailTemplateService
	 */
	public function setExtensionKey($extensionKey) {
		$this->extensionKey = $extensionKey;
		return $this;
	}

606
	/**
607
	 * @param array $markers
608
609
	 * @return MailTemplateService
	 */
610
611
	public function setMarkers(array $markers) {
		$this->markers = $markers;
612
613
		return $this;
	}
614
615

	/**
616
	 * @param string $bccAddresses
617
618
	 * @return MailTemplateService
	 */
619
	public function setBccAddresses($bccAddresses) {
620
621
		if ($bccAddresses) {
			$this->bccAddresses = $bccAddresses;
622
			$this->mailMessage->setBcc(GeneralUtility::trimExplode(',', $this->bccAddresses));
623
624
		}

625
626
627
		return $this;
	}

628
629
630
631
632
633
634
635
	/**
	 * @param int $priority
	 * @return MailTemplateService
	 */
	public function setPriority($priority) {
		$this->priority = $priority;
		return $this;
	}
636
637
638

	/**
	 * @param Swift_OutputByteStream $data
Paul Ilea's avatar
Paul Ilea committed
639
	 * @param string $filename
640
641
642
643
644
645
646
647
648
649
650
	 * @param string $contentType
	 * @return MailTemplateService
	 */
	public function addAttachment($data, $filename, $contentType) {
		$attachment = Swift_Attachment::newInstance()
			->setFilename($filename)
			->setContentType($contentType)
			->setBody($data);
		$this->mailMessage->attach($attachment);
		return $this;
	}
651
652
653
654
655
656
657
658

	/**
	 * @return MailMessage
	 */
	public function getMailMessage() {
		return $this->mailMessage;
	}

659
660
661
662
663
664
	/**
	 * use all values from the given template
	 *
	 * @param Template $template
	 */
	private function loadTemplateValues($template) {
665
666
667
668
669
670
671
672
673
674
675
676
677
678
		$fromName = $template->getFromName();
		if ($fromName === '' && $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromName']) {
			$fromName = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromName'];
		}

		$fromMail = $template->getFromMail();
		if (!filter_var($fromMail, FILTER_VALIDATE_EMAIL)) {
			$fromMail = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'];
			if (!filter_var($GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'], FILTER_VALIDATE_EMAIL)) {
				$fromMail = 'noreply@example.com';
			}
		}

		$this->setFromAddress($fromMail, $fromName);
679
680
681
		$this->setCcAddresses($template->getCc());
		$this->setBccAddresses($template->getBcc());
		$this->setReplyToAddress($template->getReplyTo());
682
683
		$this->setFromName($fromName);

684
685
686
687
688
689
690
691
		$this->setReplyToAddress($template->getReplyTo());
	}

	/**
	 * @param string $fromName
	 */
	public function setFromName($fromName) {
		$this->fromName = $fromName;
692
	}
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713

	/**
	 * Provides translation for the marker data type
	 *
	 * @param string $markerType
	 */
	public static function getReadableMarkerType($markerType) {
		switch ($markerType) {
			case self::MARKER_TYPE_STRING :
				LocalizationUtility::translate('backend.marker.type.string', 'sg_mail');
				break;
			case self::MARKER_TYPE_ARRAY :
				LocalizationUtility::translate('backend.marker.type.array', 'sg_mail');
				break;
			case self::MARKER_TYPE_OBJECT :
				LocalizationUtility::translate('backend.marker.type.object', 'sg_mail');
				break;
			default:
				LocalizationUtility::translate('backend.marker.type.mixed', 'sg_mail');
		}
	}
714
715
716
717
718
719
720
721
722
723
724

	/**
	 * set the page id from which this was called
	 *
	 * @param int $pid
	 * @return MailTemplateService
	 */
	public function setPid($pid) {
		$this->pid = (int) $pid;
		return $this;
	}
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761

	/**
	 * Iterate over all installed extensions and look for sg_mail configuration files
	 * If found, register the template(s)
	 *
	 * @throws \BadFunctionCallException
	 */
	public static function registerExtensions() {
		// clear registerArray
		self::$registerArray = [];

		$extensionList = ExtensionManagementUtility::getLoadedExtensionListArray();

		foreach ($extensionList as $extensionName) {
			$extensionConfigDirectory = ExtensionManagementUtility::extPath($extensionName);
			$extensionConfigDirectory .= '/Configuration/MailTemplates';
			$configFiles = GeneralUtility::getFilesInDir($extensionConfigDirectory);

			foreach ($configFiles as $configFile) {
				$configArray = (include $extensionConfigDirectory . '/' . $configFile);
				self::registerByConfigArray($configArray, $extensionName);
			}
		}
	}

	/**
	 * Register a template with a config array
	 *
	 * @param array $config
	 * @param string $extensionName
	 * @throws \BadFunctionCallException
	 */
	private static function registerByConfigArray(array $config = [], $extensionName) {
		$extensionKey = $config['extension_key'];
		$templateKey = $config['template_key'];
		$templatePath = ExtensionManagementUtility::extPath(
				$extensionName
762
			) . 'Resources/Private/Templates/SgMail/' . ucfirst($config['template_key'] . '/');
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780

		if ($config['template_path']) {
			$templatePath = $config['template_key'];
		}

		$description = $config['description'];
		$subject = $config['subject'];
		$marker = $config['markers'];

		self::$registerArray[$extensionKey][$templateKey] = [
			'templatePath' => $templatePath,
			'description' => $description,
			'marker' => $marker,
			'extension' => $extensionKey,
			'templateName' => $templateKey,
			'subject' => $subject
		];
	}
781
}