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;
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
172
		$this->tsSettings = $typoScriptSettingsService->getSettings(0, 'tx_sgmail');
		$this->language = $this->tsSettings['templateDefaultLanguage'];
173
174
175
176
		/** @var TemplateRepository templateRepository */
		$this->templateRepository = $this->objectManager->get(TemplateRepository::class);
		/** @var PersistenceManager persistenceManager */
		$this->persistenceManager = $this->objectManager->get(PersistenceManager::class);
177

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

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

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

193
		$this->bccAddresses = GeneralUtility::trimExplode(',', $this->tsSettings['mail']['default']['bcc']);
194
195
196
197
198
199
200
201
202
203
204
205
206
207
		$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]);
			}
		}

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

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

Torsten Oppermann's avatar
Torsten Oppermann committed
217
	/**
Torsten Oppermann's avatar
Torsten Oppermann committed
218
	 * register a template with sg_mail
Fabian Galinski's avatar
Fabian Galinski committed
219
	 *
220
221
222
	 * 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
	 *
223
	 * @deprecated public usage of this function is deprecated. use registerByFile instead
224
	 * @param string $extension
Torsten Oppermann's avatar
Torsten Oppermann committed
225
226
	 * @param string $templateName
	 * @param string $templatePath
227
	 * @param mixed $description
228
	 * @param array $markers
229
	 * @param mixed $subject
230
	 * @param string $usage
Torsten Oppermann's avatar
Torsten Oppermann committed
231
	 */
232
	public static function registerTemplate(
233
		$extension, $templateName, $templatePath, $description, array $markers, $subject, $usage = ''
234
	) {
235
		MailTemplateService::$registerArray[$extension][$templateName] = [
236
			'templatePath' => $templatePath,
237
			'description' => $description,
238
			'marker' => $markers,
239
			'extension' => $extension,
240
			'templateName' => $templateName,
241
242
			'subject' => $subject,
			'usage' => $usage
243
244
		];
	}
245

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

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

270
271
272
273
274
275
276
277
278
	/**
	 * 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') {
279
		$languagePath = 'LLL:EXT:' . $extensionKey . '/Resources/Private/Language/locallang.xlf:' . $translationKey;
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

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

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

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

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

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

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

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

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

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

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

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

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

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

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

405
406
407
408
		// 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) {
409

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

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

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

		return TRUE;
432
433
434
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

542
543
544
545
		return $this;
	}

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

555
556
557
558
		return $this;
	}

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

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

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

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

626
627
628
		return $this;
	}

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

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

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

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

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

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

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

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

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

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

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