MailTemplateService.php 22 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
	const DEFAULT_TEMPLATE_PATH = 'Resources/Private/Templates/SgMail/';
54

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

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

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

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

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

	/**
81
	 * @var string $language
82
	 */
83
	private $language = 'default';
84
85

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

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

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

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

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

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

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

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

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

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

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

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

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

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

165
166
167
168
169
170
		/** @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);
171
		$this->tsSettings = $typoScriptSettingsService->getSettings(0, 'tx_sgmail');
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
325
326
		if ($this->pid) {
			$pageUid = $this->pid;
		}
327
		$siteRootId = BackendService::getSiteRoot($pageUid);
328

329
		/** @var Template $template */
330
		$template = $this->templateRepository->findOneByTemplate(
331
			$this->extensionKey, $this->templateName, $this->language, $siteRootId
332
		);
333

334
335
336
337
338
		// if there is a template, prefer those values
		if ($template) {
			$this->loadTemplateValues($template);
		}

339
340
		// If there is no template for this language, use the default template
		if ($template === NULL) {
341

342
343
344
345
346
			$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 {
347
				$defaultTemplateFile = $templatePath . 'template.html';
348

349
350
351
352
353
				if (file_exists($defaultTemplateFile)) {
					$defaultTemplateContent = file_get_contents($defaultTemplateFile);
				} else {
					return FALSE;
				}
354
			}
355
356
		}

Torsten Oppermann's avatar
Torsten Oppermann committed
357
358
		if ($isPreview) {
			$previewMarker = [];
Paul Ilea's avatar
Paul Ilea committed
359
			/** @var array $markerArray */
Torsten Oppermann's avatar
Torsten Oppermann committed
360
361
			$markerArray = self::$registerArray[$this->extensionKey][$this->templateName]['marker'];
			foreach ($markerArray as $marker) {
362
363
364
365
366
367
368
369
370
371
372
373
				$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 {
374
						$temporaryMarkerArray = [$markerPathSegment => $temporaryMarkerArray];
375
					}
376
				}
377
				$previewMarker = array_merge_recursive($previewMarker, $temporaryMarkerArray);
Torsten Oppermann's avatar
Torsten Oppermann committed
378
			}
379
			$this->setIgnoreMailQueue(TRUE);
Torsten Oppermann's avatar
Torsten Oppermann committed
380
381
382
			$this->setMarkers($previewMarker);
		}

383
		/** @var StandaloneView $emailView */
384
		$emailView = $this->objectManager->get(StandaloneView::class);
385

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

			$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
				);
			}
401
		}
402
		$this->mailMessage->setSubject($subject);
403

404
		$emailView->assignMultiple($this->markers);
405
		$emailBody = $emailView->render();
406

407
408
409
410
		// 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) {
411

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

			if (!$isPreview) {
				$this->addMailToMailQueue(
					$this->extensionKey, $this->templateName, $subject, $emailBody, $this->priority,
420
					$currentTimestamp, $currentTimestamp, $this->language, $siteRootId
421
422
				);
			}
423

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

		return TRUE;
434
435
436
	}

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

460
		$mail->setFromAddress($this->fromAddress);
461
		$mail->setFromName($this->fromName);
462

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

473
		$mailRepository = $this->objectManager->get(MailRepository::class);
474
		$mailRepository->add($mail);
475
		$this->persistenceManager->persistAll();
476
	}
477

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

		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());
495

496
			if ($mailToSend->getBccAddresses()) {
497
498
499
				$this->mailMessage->setBcc(GeneralUtility::trimExplode(',', $mailToSend->getBccAddresses()));
			}

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

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

508
509
			$dateTime = new DateTime();
			$mailToSend->setLastSendingTime($dateTime->getTimestamp());
510
			$this->mailMessage->send();
511
			$mailRepository->update($mailToSend);
512
513
514
		}
	}

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

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

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

544
545
546
547
		return $this;
	}

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

557
558
559
560
		return $this;
	}

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

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
		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;
	}

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

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

628
629
630
		return $this;
	}

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

	/**
	 * @param Swift_OutputByteStream $data
Paul Ilea's avatar
Paul Ilea committed
642
	 * @param string $filename
643
644
645
646
647
648
649
650
651
652
653
	 * @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;
	}
654
655
656
657
658
659
660
661

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

662
663
664
665
666
667
	/**
	 * use all values from the given template
	 *
	 * @param Template $template
	 */
	private function loadTemplateValues($template) {
668
669
670
671
672
673
674
675
676
677
678
679
680
681
		$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);
682
683
684
		$this->setCcAddresses($template->getCc());
		$this->setBccAddresses($template->getBcc());
		$this->setReplyToAddress($template->getReplyTo());
685
686
		$this->setFromName($fromName);

687
688
689
690
691
692
693
694
		$this->setReplyToAddress($template->getReplyTo());
	}

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

	/**
	 * 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');
		}
	}
717
718
719
720
721
722
723
724
725
726
727

	/**
	 * set the page id from which this was called
	 *
	 * @param int $pid
	 * @return MailTemplateService
	 */
	public function setPid($pid) {
		$this->pid = (int) $pid;
		return $this;
	}
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
762

	/**
	 * 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'];
763
764
765
766
767
768
769
770

		// transform template directory name: your_templates => YourTemplates/
		$templateDirectoryParts = GeneralUtility::trimExplode('_', $config['template_key']);
		$templateDirectory = '';
		foreach ($templateDirectoryParts as $part) {
			$templateDirectory .= ucfirst($part);
		}
		$templateDirectory .= '/';
771
772
773
		$templatePath = ExtensionManagementUtility::extPath(
				$extensionName
			) . self::DEFAULT_TEMPLATE_PATH . $templateDirectory;
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791

		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
		];
	}
792
}