MailTemplateService.php

<?php

namespace SGalinski\SgMail\Service;

/***************************************************************
 *  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!
 ***************************************************************/

use DateTime;
use SGalinski\SgMail\Domain\Model\Mail;
use SGalinski\SgMail\Domain\Model\Template;
use SGalinski\SgMail\Domain\Repository\LayoutRepository;
use SGalinski\SgMail\Domain\Repository\MailRepository;
use SGalinski\SgMail\Domain\Repository\TemplateRepository;
use Swift_Attachment;
use Swift_OutputByteStream;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Mail\MailMessage;
use TYPO3\CMS\Core\Resource\File;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Routing\SiteMatcher;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\VersionNumberUtility;
use TYPO3\CMS\Extbase\Domain\Model\FileReference;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
use TYPO3\CMS\Extbase\Utility\LocalizationUtility;
use TYPO3\CMS\Fluid\View\StandaloneView;
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;

/**
 * MailTemplateService
 */
class MailTemplateService {
	const MARKER_TYPE_STRING = 'String';
	const MARKER_TYPE_ARRAY = 'Array';
	const MARKER_TYPE_OBJECT = 'Object';
	const MARKER_TYPE_FILE = 'File';
	const DEFAULT_LANGUAGE = 'default';
	const DEFAULT_TEMPLATE_PATH = 'Resources/Private/Templates/SgMail/';
	const CACHE_NAME = 'sg_mail_registerArrayCache';
	const CACHE_LIFETIME_IN_SECONDS = 86400;
	const REGISTER_FILE = 'Register.php';
	const CONFIG_PATH = 'Configuration/MailTemplates';

	/**
	 * @var array
	 */
	private static $templateObjectCache = [];

	/**
	 * @var array
	 */
	private static $mailObjectCache = [];

	/**
	 * @var string $toAddresses
	 */
	private $toAddresses = '';

	/**
	 * @var string $fromAddress
	 */
	private $fromAddress = '';

	/**
	 * @var string $ccAddresses
	 */
	private $ccAddresses;

	/**
	 * @var string $replyToAddress
	 */
	private $replyToAddress = '';

	/**
	 * @var string $language
	 */
	private $language = 'default';

	/**
	 * @var boolean $ignoreMailQueue
	 */
	private $ignoreMailQueue = FALSE;

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

	/**
	 * @var string $templateName
	 */
	private $templateName;

	/**
	 * @var string $subject
	 */
	private $subject;

	/**
	 * @var string $overwrittenEmailBody
	 */
	private $overwrittenEmailBody = '';

	/**
	 * @var string $overwrittenBcc
	 */
	private $overwrittenBcc;

	/**
	 * @var string $overwrittenFromName
	 */
	private $overwrittenFromName;

	/**
	 * @var string $overwrittenFromMail
	 */
	private $overwrittenFromMail;

	/**
	 * @var string $overwrittenReplyTo
	 */
	private $overwrittenReplyTo;

	/**
	 * @var string $overwrittenToAddresses
	 */
	private $overwrittenToAddresses;

	/**
	 * @var string $overwrittenCc
	 */
	private $overwrittenCc;

	/**
	 * @var string $extensionKey
	 */
	private $extensionKey;

	/**
	 * @var array $markers
	 */
	private $markers;

	/**
	 * @var array $markerLabels
	 */
	private $markerLabels;

	/**
	 * @var string $bccAddresses
	 */
	private $bccAddresses;

	/**
	 * @var int
	 */
	private $priority = Mail::PRIORITY_LOWEST;

	/**
	 * @var int
	 */
	private $pid;

	/**
	 * @var string
	 */
	private $fromName = '';

	/**
	 * @var \SGalinski\SgMail\Domain\Repository\TemplateRepository
	 */
	protected $templateRepository;

	/**
	 * @var \SGalinski\SgMail\Domain\Repository\LayoutRepository
	 */
	protected $layoutRepository;

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

	/**
	 * @var \TYPO3\CMS\Extbase\Object\ObjectManager
	 */
	protected $objectManager;

	/**
	 * @var TYPO3\CMS\Core\Resource\ResourceFactory
	 */
	protected $resourceFactory;

	/**
	 * @var string
	 */
	private $mailBodyToSend;

	/**
	 * @var string
	 */
	private $subjectToSend;

	/*
	 * @var string
	 */
	private $defaultFromAddress;

	/**
	 * @var string
	 */
	private $defaultFromName;

	/**
	 * @return string
	 */
	public function getOverwrittenBcc(): string {
		return $this->overwrittenBcc;
	}

	/**
	 * @param string $overwrittenBcc
	 */
	public function setOverwrittenBcc(string $overwrittenBcc): void {
		$this->overwrittenBcc = $overwrittenBcc;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenCc(): string {
		return $this->overwrittenCc;
	}

	/**
	 * @param string $overwrittenCc
	 */
	public function setOverwrittenCc(string $overwrittenCc): void {
		$this->overwrittenCc = $overwrittenCc;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenFromName(): string {
		return $this->overwrittenFromName;
	}

	/**
	 * @param string $overwrittenFromName
	 */
	public function setOverwrittenFromName(string $overwrittenFromName): void {
		$this->overwrittenFromName = $overwrittenFromName;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenFromMail(): string {
		return $this->overwrittenFromMail;
	}

	/**
	 * @param string $overwrittenFromMail
	 */
	public function setOverwrittenFromMail(string $overwrittenFromMail): void {
		$this->overwrittenFromMail = $overwrittenFromMail;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenReplyTo(): string {
		return $this->overwrittenReplyTo;
	}

	/**
	 * @param string $overwrittenReplyTo
	 */
	public function setOverwrittenReplyTo(string $overwrittenReplyTo): void {
		$this->overwrittenReplyTo = $overwrittenReplyTo;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenToAddresses(): string {
		return $this->overwrittenToAddresses;
	}

	/**
	 * @param string $overwrittenToAddresses
	 */
	public function setOverwrittenToAddresses(string $overwrittenToAddresses): void {
		$this->overwrittenToAddresses = $overwrittenToAddresses;
	}

	/**
	 * MailTemplateService constructor.
	 *
	 * @param string $templateName
	 * @param string $extensionKey
	 * @param array $markers
	 * @param array $markerLabels
	 * @throws \InvalidArgumentException
	 */
	public function __construct($templateName = '', $extensionKey = '', $markers = [], $markerLabels = []) {
		$this->templateName = $templateName;
		$this->extensionKey = $extensionKey;
		$this->markers = $markers;
		$this->markerLabels = $markerLabels;

		/** @var ObjectManager objectManager */
		$this->objectManager = GeneralUtility::makeInstance(ObjectManager::class);
		$this->mailMessage = $this->objectManager->get(MailMessage::class);
		$typoScriptSettingsService = $this->objectManager->get(TypoScriptSettingsService::class);
		$tsSettings = $typoScriptSettingsService->getSettings(0, 'tx_sgmail');
		$this->templateRepository = $this->objectManager->get(TemplateRepository::class);
		$this->layoutRepository = $this->objectManager->get(LayoutRepository::class);
		$this->persistenceManager = $this->objectManager->get(PersistenceManager::class);
		$this->resourceFactory = $this->objectManager->get(ResourceFactory::class);

		// use defaultMailFromAddress if it is provided in LocalConfiguration.php; use the sg_mail TS setting as fallback
		if (\filter_var($GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'], FILTER_VALIDATE_EMAIL)) {
			$this->fromAddress = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'];
			$this->defaultFromAddress = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromAddress'];
		} else if (!\filter_var($tsSettings['mail']['default']['from'], FILTER_VALIDATE_EMAIL)) {
			$this->fromAddress = 'noreply@example.org';
			$this->defaultFromAddress = 'noreply@example.org';
		} else {
			$this->fromAddress = $tsSettings['mail']['default']['from'];
			$this->defaultFromAddress = $tsSettings['mail']['default']['from'];
		}

		if ($GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromName']) {
			$this->fromName = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromName'];
			$this->defaultFromName = $GLOBALS['TYPO3_CONF_VARS']['MAIL']['defaultMailFromName'];
		}

		$this->mailMessage->setFrom($this->fromAddress, $this->fromName);
		$this->bccAddresses = GeneralUtility::trimExplode(',', $tsSettings['mail']['default']['bcc']);
		$this->ccAddresses = GeneralUtility::trimExplode(',', $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]);
			}
		}

		if (\count($this->bccAddresses) > 0) {
			$this->mailMessage->setBcc($this->bccAddresses);
		}

		if (\count($this->ccAddresses) > 0) {
			$this->mailMessage->setCc($this->ccAddresses);
		}
	}

	/**
	 * @param string $fromName
	 */
	public function setFromName($fromName) {
		$this->fromName = $fromName;
	}

	/**
	 * 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;
			case self::MARKER_TYPE_FILE:
				LocalizationUtility::translate('backend.marker.type.file', 'sg_mail');
				break;
			default:
				LocalizationUtility::translate('backend.marker.type.mixed', 'sg_mail');
		}
	}

	/**
	 * @param string $toAddresses
	 * @return MailTemplateService
	 */
	public function setToAddresses($toAddresses): MailTemplateService {
		$normalizedToAddresses = trim(preg_replace('~\x{00a0}~iu', ' ', $toAddresses));
		$this->toAddresses = $normalizedToAddresses;

		$addressesArray = GeneralUtility::trimExplode(',', $normalizedToAddresses, TRUE);
		if (\count($addressesArray) > 1) {
			$normalizedToAddresses = $addressesArray;
		}
		$this->mailMessage->setTo($normalizedToAddresses);
		return $this;
	}

	/**
	 * @param string $fromAddress
	 * @param string $fromName
	 * @return MailTemplateService
	 */
	public function setFromAddress($fromAddress, $fromName = ''): MailTemplateService {
		if ($fromAddress) {
			$this->fromAddress = $fromAddress;
			$this->mailMessage->setFrom($fromAddress, $fromName);
		}

		return $this;
	}

	/**
	 * @param string $ccAddresses
	 * @return MailTemplateService
	 */
	public function setCcAddresses($ccAddresses): MailTemplateService {
		if ($ccAddresses) {
			$this->ccAddresses = $ccAddresses;
			$this->mailMessage->setCc(GeneralUtility::trimExplode(',', $this->ccAddresses));
		}

		return $this;
	}

	/**
	 * @param string $replyToAddress
	 * @return MailTemplateService
	 */
	public function setReplyToAddress($replyToAddress): MailTemplateService {
		if ($replyToAddress) {
			$this->replyToAddress = $replyToAddress;
			$this->mailMessage->setReplyTo($replyToAddress);
		}

		return $this;
	}

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

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

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

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

	/**
	 * @return string|string[]|null
	 */
	public function getMailBodyToSend() {
		return $this->mailBodyToSend;
	}

	/**
	 * @param string|string[]|null $mailBodyToSend
	 */
	public function setMailBodyToSend($mailBodyToSend): void {
		$this->mailBodyToSend = $mailBodyToSend;
	}

	/**
	 * @return string
	 */
	public function getSubjectToSend(): string {
		return $this->subjectToSend;
	}

	/**
	 * @param string $subjectToSend
	 */
	public function setSubjectToSend(string $subjectToSend): void {
		$this->subjectToSend = $subjectToSend;
	}

	/**
	 * @param array $markers
	 * @return MailTemplateService
	 */
	public function addMarkers(array $markers): MailTemplateService {
		$this->setMarkers(\array_merge($this->markers, $markers));
		return $this;
	}

	/**
	 * @param array $markers
	 * @return MailTemplateService
	 */
	public function setMarkers(array $markers): MailTemplateService {
		$this->markers = $markers;
		foreach ($markers as $key => $currentMarker) {
			if (!\is_array($currentMarker) || !isset($currentMarker['markerLabel'])) {
				continue;
			}
			$this->markerLabels[$key] = $currentMarker['markerLabel'];
		}

		return $this;
	}

	/**
	 * @param string $bccAddresses
	 * @return MailTemplateService
	 */
	public function setBccAddresses($bccAddresses): MailTemplateService {
		if ($bccAddresses) {
			$this->bccAddresses = $bccAddresses;
			$this->mailMessage->setBcc(GeneralUtility::trimExplode(',', $this->bccAddresses));
		}

		return $this;
	}

	/**
	 * @param int $priority
	 * @return MailTemplateService
	 */
	public function setPriority($priority): MailTemplateService {
		$this->priority = $priority;
		return $this;
	}

	/**
	 * @param Swift_OutputByteStream $data
	 * @param string $filename
	 * @param string $contentType
	 * @return MailTemplateService
	 */
	public function addAttachment($data, $filename, $contentType): MailTemplateService {
		$attachment = Swift_Attachment::newInstance()
			->setFilename($filename)
			->setContentType($contentType)
			->setBody($data);
		$this->mailMessage->attach($attachment);
		return $this;
	}

	/**
	 * Adds a file resource as attachment
	 *
	 * @param FileReference $fileReference
	 * @param File $file
	 *
	 * @return MailTemplateService
	 * @throws \TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException
	 */
	public function addFileResourceAttachment(
		FileReference $fileReference = NULL, File $file = NULL
	): MailTemplateService {
		if (!$file) {
			if (!$fileReference) {
				return $this;
			}

			$originalResource = $fileReference->getOriginalResource();
			if (!$originalResource) {
				return $this;
			}

			$file = $originalResource->getOriginalFile();
			if (!$file) {
				return $this;
			}
		}

		$coreFileReferenceMailFile = $this->resourceFactory->createFileReferenceObject(
			[
				'uid_local' => $file->getUid(),
				'table_local' => 'sys_file',
				'uid' => uniqid('NEW_MAIL', TRUE)
			]
		);

		$newFileReference = GeneralUtility::makeInstance(FileReference::class);
		$newFileReference->setOriginalResource($coreFileReferenceMailFile);

		$this->markers[] = $newFileReference;
		return $this;
	}

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

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

	/**
	 * Checks if a template is blacklisted for a given siteroot id
	 *
	 * @param string $extensionKey
	 * @param string $templateName
	 * @param int $siteRootId
	 * @return boolean
	 * @throws \InvalidArgumentException
	 * @throws \BadFunctionCallException
	 * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
	 */
	public static function isTemplateBlacklisted($extensionKey, $templateName, $siteRootId): bool {
		$nonBlacklistedTemplates = BackendService::getNonBlacklistedTemplates($siteRootId);
		if ($nonBlacklistedTemplates[$extensionKey]) {
			return $nonBlacklistedTemplates[$extensionKey][$templateName] ? FALSE : TRUE;
		}

		return TRUE;
	}

	/**
	 * @return string
	 */
	public function getSubject(): string {
		return $this->subject;
	}

	/**
	 * @param string $subject
	 */
	public function setSubject(string $subject) {
		$this->subject = $subject;
	}

	/**
	 * @return string
	 */
	public function getOverwrittenEmailBody(): string {
		return $this->overwrittenEmailBody;
	}

	/**
	 * @param string $overwrittenEmailBody
	 */
	public function setOverwrittenEmailBody(string $overwrittenEmailBody) {
		$this->overwrittenEmailBody = $overwrittenEmailBody;
	}

	/**
	 * 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'): array {
		$languagePath = 'LLL:EXT:' . $extensionKey . '/Resources/Private/Language/locallang.xlf:' . $translationKey;
		// 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;
	}

	/**
	 * Set preview markers for the template editor
	 *
	 * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
	 */
	public function setPreviewMarkers() {
		$previewMarker = [];

		// get default template content from register array
		$registerService = GeneralUtility::makeInstance(RegisterService::class);
		/** @var array $markerArray */
		$markerArray = $registerService->getRegisterArray()[$this->extensionKey][$this->templateName]['marker'];

		foreach ($markerArray as $marker) {
			$markerPath = GeneralUtility::trimExplode('.', $marker['marker']);
			$temporaryMarkerArray = [];
			foreach (\array_reverse($markerPath) as $index => $markerPathSegment) {
				if ($index === 0) {
					if ($marker['markerLabel']) {
						$markerPathSegment = $marker['markerLabel'];
					}

					if ($marker['backend_translation_key']) {
						$temporaryMarkerArray[$markerPathSegment] = LocalizationUtility::translate(
							$marker['backend_translation_key'], $marker['extension_key']
						);
					} else {
						$temporaryMarkerArray[$markerPathSegment] = $marker['value'];
					}
				} else {
					$temporaryMarkerArray = [$markerPathSegment => $temporaryMarkerArray];
				}
			}
			/** @noinspection SlowArrayOperationsInLoopInspection */
			$previewMarker = \array_merge_recursive($previewMarker, $temporaryMarkerArray);
		}
		$this->setMarkers($previewMarker);
	}

	/**
	 * Parses markers in an email View.
	 * !!! CHANGES THE SOURCE PATH AND IT SHOULD BE RESET BACK TO THE ORIGINAL!!!
	 *
	 * @param string $text
	 * @param StandaloneView $emailView
	 * @return mixed
	 */
	protected function parseMarkers($text, $emailView) {
		if (strpos($text, '{') !== FALSE) {
			$emailView->setTemplateSource($text);
			return $emailView->render();
		}

		return $text;
	}

	/**
	 * Gets the current PageUid
	 *
	 * @return int
	 */
	protected function getPageUid(): int {
		if (TYPO3_MODE === 'FE') {
			/** @var TypoScriptFrontendController $typoscriptFrontendController */
			$typoscriptFrontendController = $GLOBALS['TSFE'];
			$pageUid = (int) $typoscriptFrontendController->id;
		} else {
			$pageUid = (int) GeneralUtility::_GP('id');
		}

		if ($this->pid) {
			$pageUid = $this->pid;
		}

		if ($pageUid === 0) {
			$pageUid = $this->getAnyRootPageUid();
		}
		return $pageUid;
	}

	/**
	 * Gets the page uid of any root page in the page tree
	 *
	 * @return int
	 */
	private function getAnyRootPageUid() {
		$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(
			'pages'
		);
		$rootPageRows = $queryBuilder->select('*')
			->from('pages')
			->where(
				$queryBuilder->expr()->eq(
					'is_siteroot', 1
				)
			)
			->andWhere(
				$queryBuilder->expr()->eq(
					'hidden', 0
				)
			)
			->execute()->fetchAll();

		if ($rootPageRows && \count($rootPageRows)) {
			$pageUid = (int) $rootPageRows[0]['uid'];
		}
		return $pageUid;
	}

	/**
	 * Get the hash for the object cache
	 *
	 * @param $extensionKey
	 * @param $templateName
	 * @param $siteRootId
	 * @param $languageId
	 * @return string
	 */
	private function getTemplateHash($extensionKey, $templateName, $siteRootId, $languageId) {
		return md5($extensionKey . '_' . $templateName . '_' . $siteRootId . '_' . $languageId);
	}

	/**
	 * Get the template object
	 *
	 * @param int $siteRootId
	 * @return null|object|Template|FALSE
	 * @throws \Exception
	 */
	private function getTemplate($siteRootId) {
		$isTemplateBlacklisted = self::isTemplateBlacklisted($this->extensionKey, $this->templateName, $siteRootId);
		if ($isTemplateBlacklisted) {
			throw new \Exception('The template is blacklisted');
		}

		$templateHash = $this->getTemplateHash($this->extensionKey, $this->templateName, $siteRootId, $this->language);
		if (isset(self::$templateObjectCache[$templateHash])
			&& self::$templateObjectCache[$templateHash] instanceof Template) {
			return self::$templateObjectCache[$templateHash];
		}
		/** @var Template $template */
		$template = $this->templateRepository->findOneByTemplate(
			$this->extensionKey, $this->templateName, $this->language, $siteRootId
		);

		if ($template === NULL) {
			$template = $this->templateRepository->findOneByTemplate(
				$this->extensionKey, $this->templateName, 'default', $siteRootId
			);
		}
		self::$templateObjectCache[$templateHash] = $template;
		return $template;
	}

	/**
	 * Get the default content for this template
	 *
	 * @param Template|null $template
	 * @param RegisterService $registerService
	 * @return bool|false|string
	 * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
	 */
	protected function getDefaultTemplateContent($template, $registerService) {
		$defaultTemplateContent =
			$registerService->getRegisterArray()[$this->extensionKey][$this->templateName]['templateContent'];

		// If there is no template for this language, use the default template
		if ($template === NULL && $defaultTemplateContent === NULL) {
			$templatePath =
				$registerService->getRegisterArray()[$this->extensionKey][$this->templateName]['templatePath'];

			// only standard template file is considered since version 4.1
			$defaultTemplateFile = $templatePath . 'template.html';
			if (\file_exists($defaultTemplateFile)) {
				$defaultTemplateContent = \file_get_contents($defaultTemplateFile);
			} else {
				// use configured default html template
				/** @var TypoScriptSettingsService $typoScriptSettingsService */
				$typoScriptSettingsService = $this->objectManager->get(TypoScriptSettingsService::class);
				$tsSettings = $typoScriptSettingsService->getSettings(0, 'tx_sgmail');
				$defaultTemplateFile = GeneralUtility::getFileAbsFileName(
					$tsSettings['mail']['defaultHtmlTemplate']
				);

				if (\file_exists($defaultTemplateFile)) {
					$defaultTemplateContent = \file_get_contents($defaultTemplateFile);
				} else {
					return FALSE;
				}
			}
		}
		return $defaultTemplateContent;
	}

	/**
	 * Sets the values to send the mail with from the template or register service
	 *
	 * @param Template|null $template
	 * @param RegisterService $registerService
	 * @param string $defaultTemplateContent
	 * @param int $siteRootId
	 * @param boolean $isNewsletter
	 * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
	 */
	protected function extractValuesForMail($template, RegisterService $registerService, $defaultTemplateContent,
		$siteRootId, $isNewsletter): void {
		/** @var StandaloneView $emailView */
		$emailView = $this->objectManager->get(StandaloneView::class);
		$emailView->assignMultiple($this->markers);
		$emailView->assign('all_fields', $this->getAllMarker($this->markers));

		$overwrittenEmailBody = $this->getOverwrittenEmailBody();
		$overwrittenSubject = '';
		if ($this->subject !== '' && $this->subject !== NULL) {
			$overwrittenSubject = $this->subject;
		}

		// parse markers
		if ($template !== NULL) {
			$subject = $this->parseMarkers(
				trim(empty($overwrittenSubject) ? $template->getSubject() : $overwrittenSubject),
				$emailView
			);

			$layoutId = $template->getLayout();
			$templateContent = $template->getContent();
			$this->setSubjectToSend($subject);
		} else {
			$subject = $registerService->getRegisterArray()[$this->extensionKey][$this->templateName]['subject'];
			if (\is_array($subject)) {
				$subject = \trim(
					$registerService->getRegisterArray()
					[$this->extensionKey][$this->templateName]['subject'][$this->language]
				);
			}
			$subject = $this->parseMarkers(
				(empty($overwrittenSubject) ? $subject : $overwrittenSubject),
				$emailView
			);

			$layoutId = 0;
			$templateContent = $defaultTemplateContent;
		}

		$this->setSubjectToSend($subject);
		//TODO: is this object even in use somewhere?
		$this->mailMessage->setSubject($subject);

		$fromMail = '';
		if (!$isNewsletter && $template !== NULL) {
			// if it's a non-newsletter email with a template:
			// get the values explicitly from the template and parse the markers
			$fromMail = $this->parseMarkers($template->getFromMail(), $emailView);
		} elseif ($this->fromAddress === $this->defaultFromAddress) {
			// in other cases (newsletter or no template) - check for overwritten values
			$fromMail = $this->parseMarkers(
				empty($this->overwrittenFromMail) && $template ? $template->getFromMail() : $this->overwrittenFromMail,
				$emailView
			);
		}
		if ($fromMail) { // we don't want to override the default in that case
			$this->setFromAddress($fromMail);
		}