custom/plugins/FourtwosixThemeExtension/src/Decorator/Core/Content/Flow/Dispatching/Action/SendMailActionDecorator.php line 118

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace FourtwosixThemeExtension\Decorator\Core\Content\Flow\Dispatching\Action;
  7. use Shopware\Core\Content\Flow\Dispatching\Action\SendMailAction as Decorated;
  8. use Doctrine\DBAL\Connection;
  9. use Psr\Log\LoggerInterface;
  10. use Shopware\Core\Checkout\Document\DocumentCollection;
  11. use Shopware\Core\Checkout\Document\DocumentService;
  12. use Shopware\Core\Checkout\Document\Service\DocumentGenerator;
  13. use Shopware\Core\Content\ContactForm\Event\ContactFormEvent;
  14. use Shopware\Core\Content\Flow\Dispatching\StorableFlow;
  15. use Shopware\Core\Content\Flow\Events\FlowSendMailActionEvent;
  16. use Shopware\Core\Content\Mail\Service\AbstractMailService;
  17. use Shopware\Core\Content\MailTemplate\Exception\MailEventConfigurationException;
  18. use Shopware\Core\Content\MailTemplate\Exception\SalesChannelNotFoundException;
  19. use Shopware\Core\Content\MailTemplate\MailTemplateEntity;
  20. use Shopware\Core\Content\MailTemplate\Subscriber\MailSendSubscriberConfig;
  21. use Shopware\Core\Content\Media\MediaCollection;
  22. use Shopware\Core\Content\Media\MediaEntity;
  23. use Shopware\Core\Content\Media\MediaService;
  24. use Shopware\Core\Defaults;
  25. use Shopware\Core\Framework\Adapter\Translation\Translator;
  26. use Shopware\Core\Framework\Context;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  28. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InconsistentCriteriaIdsException;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  31. use Shopware\Core\Framework\Event\FlowEvent;
  32. use Shopware\Core\Framework\Event\MailAware;
  33. use Shopware\Core\Framework\Event\OrderAware;
  34. use Shopware\Core\Framework\Feature;
  35. use Shopware\Core\Framework\Uuid\Uuid;
  36. use Shopware\Core\Framework\Validation\DataBag\DataBag;
  37. use Shopware\Core\System\Locale\LanguageLocaleCodeProvider;
  38. use Symfony\Contracts\EventDispatcher\Event;
  39. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  41. class SendMailActionDecorator extends Decorated
  42. {
  43.     private const RECIPIENT_CONFIG_ADMIN = 'admin';
  44.     private const RECIPIENT_CONFIG_CUSTOM = 'custom';
  45.     private const RECIPIENT_CONFIG_CONTACT_FORM_MAIL = 'contactFormMail';
  47.     private EntityRepositoryInterface $mailTemplateRepository;
  48.     private MediaService $mediaService;
  49.     private EntityRepositoryInterface $mediaRepository;
  50.     private EntityRepositoryInterface $documentRepository;
  51.     private LoggerInterface $logger;
  52.     private AbstractMailService $emailService;
  53.     private EventDispatcherInterface $eventDispatcher;
  54.     private EntityRepositoryInterface $mailTemplateTypeRepository;
  55.     private Translator $translator;
  56.     private Connection $connection;
  57.     private LanguageLocaleCodeProvider $languageLocaleProvider;
  58.     private bool $updateMailTemplate;
  59.     private DocumentGenerator $documentGenerator;
  60.     private DocumentService $documentService;
  62.     public function __construct(
  63.         AbstractMailService $emailService,
  64.         EntityRepositoryInterface $mailTemplateRepository,
  65.         MediaService $mediaService,
  66.         EntityRepositoryInterface $mediaRepository,
  67.         EntityRepositoryInterface $documentRepository,
  68.         DocumentService $documentService,
  69.         DocumentGenerator $documentGenerator,
  70.         LoggerInterface $logger,
  71.         EventDispatcherInterface $eventDispatcher,
  72.         EntityRepositoryInterface $mailTemplateTypeRepository,
  73.         Translator $translator,
  74.         Connection $connection,
  75.         LanguageLocaleCodeProvider $languageLocaleProvider,
  76.         bool $updateMailTemplate
  77.     ) {
  78.         $this->mailTemplateRepository = $mailTemplateRepository;
  79.         $this->mediaService = $mediaService;
  80.         $this->mediaRepository = $mediaRepository;
  81.         $this->documentRepository = $documentRepository;
  82.         $this->logger = $logger;
  83.         $this->emailService = $emailService;
  84.         $this->eventDispatcher = $eventDispatcher;
  85.         $this->mailTemplateTypeRepository = $mailTemplateTypeRepository;
  86.         $this->translator = $translator;
  87.         $this->connection = $connection;
  88.         $this->languageLocaleProvider = $languageLocaleProvider;
  89.         $this->updateMailTemplate = $updateMailTemplate;
  90.         $this->documentGenerator = $documentGenerator;
  91.         $this->documentService = $documentService;
  93.         parent::__construct(
  94.             $emailService,
  95.             $mailTemplateRepository,
  96.             $mediaService,
  97.             $mediaRepository,
  98.             $documentRepository,
  99.             $documentService,
  100.             $documentGenerator,
  101.             $logger,
  102.             $eventDispatcher,
  103.             $mailTemplateTypeRepository,
  104.             $translator,
  105.             $connection,
  106.             $languageLocaleProvider,
  107.             $updateMailTemplate
  108.         );
  109.     }
  111.     /**
  112.      * @deprecated tag:v6.5.0 Will be removed, implement handleFlow instead
  113.      *
  114.      * @throws MailEventConfigurationException
  115.      * @throws SalesChannelNotFoundException
  116.      * @throws InconsistentCriteriaIdsException
  117.      */
  118.     public function handle(Event $event): void
  119.     {
  120.         Feature::triggerDeprecationOrThrow(
  121.             'v6.5.0.0',
  122.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0')
  123.         );
  125.         if (!$event instanceof FlowEvent) {
  126.             return;
  127.         }
  129.         $mailEvent = $event->getEvent();
  131.         $extension = $event->getContext()->getExtension(self::MAIL_CONFIG_EXTENSION);
  132.         if (!$extension instanceof MailSendSubscriberConfig) {
  133.             $extension = new MailSendSubscriberConfig(false, [], []);
  134.         }
  136.         if ($extension->skip()) {
  137.             return;
  138.         }
  140.         if (!$mailEvent instanceof MailAware) {
  141.             throw new MailEventConfigurationException('Not an instance of MailAware', \get_class($mailEvent));
  142.         }
  144.         $eventConfig = $event->getConfig();
  146.         if (empty($eventConfig['recipient'])) {
  147.             throw new MailEventConfigurationException('The recipient value in the flow action configuration is missing.', \get_class($mailEvent));
  148.         }
  150.         if (!isset($eventConfig['mailTemplateId'])) {
  151.             return;
  152.         }
  154.         $mailTemplate = $this->getMailTemplate($eventConfig['mailTemplateId'], $event->getContext());
  156.         if ($mailTemplate === null) {
  157.             return;
  158.         }
  160.         $injectedTranslator = $this->injectTranslator($mailEvent->getContext(), $mailEvent->getSalesChannelId());
  162.         $data = new DataBag();
  164.         $contactFormData = [];
  165.         if ($mailEvent instanceof ContactFormEvent) {
  166.             $contactFormData = $mailEvent->getContactFormData();
  167.             $data->set("replyTo", $contactFormData["email"]);
  168.         }
  170.         $recipients = $this->getRecipients($eventConfig['recipient'], $mailEvent->getMailStruct()->getRecipients(), $contactFormData);
  172.         if (empty($recipients)) {
  173.             return;
  174.         }
  176.         $data->set('recipients', $recipients);
  177.         $data->set('senderName', $mailTemplate->getTranslation('senderName'));
  178.         $data->set('salesChannelId', $mailEvent->getSalesChannelId());
  180.         $data->set('templateId', $mailTemplate->getId());
  181.         $data->set('customFields', $mailTemplate->getCustomFields());
  182.         $data->set('contentHtml', $mailTemplate->getTranslation('contentHtml'));
  183.         $data->set('contentPlain', $mailTemplate->getTranslation('contentPlain'));
  184.         $data->set('subject', $mailTemplate->getTranslation('subject'));
  185.         $data->set('mediaIds', []);
  187.         $attachments = array_unique($this->buildAttachments(
  188.             $event->getContext(),
  189.             $mailTemplate,
  190.             $extension,
  191.             $eventConfig,
  192.             $mailEvent instanceof OrderAware ? $mailEvent->getOrderId() : null
  193.         ), \SORT_REGULAR);
  195.         if (!empty($attachments)) {
  196.             $data->set('binAttachments', $attachments);
  197.         }
  199.         $this->eventDispatcher->dispatch(new FlowSendMailActionEvent($data, $mailTemplate, $event));
  201.         if ($data->has('templateId')) {
  202.             $this->updateMailTemplateType(
  203.                 $event->getContext(),
  204.                 $event,
  205.                 $this->getTemplateData($mailEvent),
  206.                 $mailTemplate
  207.             );
  208.         }
  210.         $templateData = array_merge([
  211.             'eventName' => $mailEvent->getName(),
  212.         ], $this->getTemplateData($mailEvent));
  214.         $this->send($data, $event->getContext(), $templateData, $attachments, $extension, $injectedTranslator);
  215.     }
  217.     /**
  218.      * @param array<string, mixed> $templateData
  219.      * @param array<mixed, mixed> $attachments
  220.      */
  221.     private function send(DataBag $data, Context $context, array $templateData, array $attachments, MailSendSubscriberConfig $extension, bool $injectedTranslator): void
  222.     {
  223.         try {
  224.             $this->emailService->send(
  225.                 $data->all(),
  226.                 $context,
  227.                 $templateData
  228.             );
  230.             $documentAttachments = array_filter($attachments, function (array $attachment) use ($extension) {
  231.                 return \array_key_exists('id', $attachment) && \in_array($attachment['id'], $extension->getDocumentIds(), true);
  232.             });
  234.             $documentAttachments = array_column($documentAttachments, 'id');
  236.             if (!empty($documentAttachments)) {
  237.                 $this->connection->executeStatement(
  238.                     'UPDATE `document` SET `updated_at` = :now, `sent` = 1 WHERE `id` IN (:ids)',
  239.                     ['ids' => Uuid::fromHexToBytesList($documentAttachments), 'now' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT)],
  240.                     ['ids' => Connection::PARAM_STR_ARRAY]
  241.                 );
  242.             }
  243.         } catch (\Exception $e) {
  244.             $this->logger->error(
  245.                 "Could not send mail:\n"
  246.                     . $e->getMessage() . "\n"
  247.                     . 'Error Code:' . $e->getCode() . "\n"
  248.                     . "Template data: \n"
  249.                     . json_encode($data->all()) . "\n"
  250.             );
  251.         }
  253.         if ($injectedTranslator) {
  254.             $this->translator->resetInjection();
  255.         }
  256.     }
  258.     /**
  259.      * @param FlowEvent|StorableFlow $event
  260.      * @param array<string, mixed> $templateData
  261.      */
  262.     private function updateMailTemplateType(
  263.         Context $context,
  264.         $event,
  265.         array $templateData,
  266.         MailTemplateEntity $mailTemplate
  267.     ): void {
  268.         if (!$mailTemplate->getMailTemplateTypeId()) {
  269.             return;
  270.         }
  272.         if (!$this->updateMailTemplate) {
  273.             return;
  274.         }
  276.         $mailTemplateTypeTranslation = $this->connection->fetchOne(
  277.             'SELECT 1 FROM mail_template_type_translation WHERE language_id = :languageId AND mail_template_type_id =:mailTemplateTypeId',
  278.             [
  279.                 'languageId' => Uuid::fromHexToBytes($context->getLanguageId()),
  280.                 'mailTemplateTypeId' => Uuid::fromHexToBytes($mailTemplate->getMailTemplateTypeId()),
  281.             ]
  282.         );
  284.         if (!$mailTemplateTypeTranslation) {
  285.             // Don't throw errors if this fails // Fix with NEXT-15475
  286.             $this->logger->error(
  287.                 "Could not update mail template type, because translation for this language does not exits:\n"
  288.                     . 'Flow id: ' . $event->getFlowState()->flowId . "\n"
  289.                     . 'Sequence id: ' . $event->getFlowState()->getSequenceId()
  290.             );
  292.             return;
  293.         }
  295.         $this->mailTemplateTypeRepository->update([[
  296.             'id' => $mailTemplate->getMailTemplateTypeId(),
  297.             'templateData' => $templateData,
  298.         ]], $context);
  299.     }
  301.     private function getMailTemplate(string $id, Context $context): ?MailTemplateEntity
  302.     {
  303.         $criteria = new Criteria([$id]);
  304.         $criteria->setTitle('send-mail::load-mail-template');
  305.         $criteria->addAssociation('media.media');
  306.         $criteria->setLimit(1);
  308.         return $this->mailTemplateRepository
  309.             ->search($criteria, $context)
  310.             ->first();
  311.     }
  313.     /**
  314.      * @throws MailEventConfigurationException
  315.      *
  316.      * @return array<string, mixed>
  317.      */
  318.     private function getTemplateData(MailAware $event): array
  319.     {
  320.         $data = [];
  322.         foreach (array_keys($event::getAvailableData()->toArray()) as $key) {
  323.             $getter = 'get' . ucfirst($key);
  324.             if (!method_exists($event, $getter)) {
  325.                 throw new MailEventConfigurationException('Data for ' . $key . ' not available.', \get_class($event));
  326.             }
  327.             $data[$key] = $event->$getter();
  328.         }
  330.         return $data;
  331.     }
  333.     /**
  334.      * @param array<string, mixed> $eventConfig
  335.      *
  336.      * @return array<mixed, mixed>
  337.      */
  338.     private function buildAttachments(
  339.         Context $context,
  340.         MailTemplateEntity $mailTemplate,
  341.         MailSendSubscriberConfig $extensions,
  342.         array $eventConfig,
  343.         ?string $orderId
  344.     ): array {
  345.         $attachments = [];
  347.         if ($mailTemplate->getMedia() !== null) {
  348.             foreach ($mailTemplate->getMedia() as $mailTemplateMedia) {
  349.                 if ($mailTemplateMedia->getMedia() === null) {
  350.                     continue;
  351.                 }
  352.                 if ($mailTemplateMedia->getLanguageId() !== null && $mailTemplateMedia->getLanguageId() !== $context->getLanguageId()) {
  353.                     continue;
  354.                 }
  356.                 $attachments[] = $this->mediaService->getAttachment(
  357.                     $mailTemplateMedia->getMedia(),
  358.                     $context
  359.                 );
  360.             }
  361.         }
  363.         if (!empty($extensions->getMediaIds())) {
  364.             $criteria = new Criteria($extensions->getMediaIds());
  365.             $criteria->setTitle('send-mail::load-media');
  367.             /** @var MediaCollection<MediaEntity> $entities */
  368.             $entities = $this->mediaRepository->search($criteria, $context);
  370.             foreach ($entities as $media) {
  371.                 $attachments[] = $this->mediaService->getAttachment($media, $context);
  372.             }
  373.         }
  375.         $documentIds = $extensions->getDocumentIds();
  377.         if (!empty($eventConfig['documentTypeIds']) && \is_array($eventConfig['documentTypeIds']) && $orderId) {
  378.             $latestDocuments = $this->getLatestDocumentsOfTypes($orderId, $eventConfig['documentTypeIds']);
  380.             $documentIds = array_unique(array_merge($documentIds, $latestDocuments));
  381.         }
  383.         if (!empty($documentIds)) {
  384.             $extensions->setDocumentIds($documentIds);
  385.             if (Feature::isActive('v6.5.0.0')) {
  386.                 $attachments = $this->mappingAttachments($documentIds, $attachments, $context);
  387.             } else {
  388.                 $attachments = $this->buildOrderAttachments($documentIds, $attachments, $context);
  389.             }
  390.         }
  392.         return $attachments;
  393.     }
  395.     private function injectTranslator(Context $context, ?string $salesChannelId): bool
  396.     {
  397.         if ($salesChannelId === null) {
  398.             return false;
  399.         }
  401.         if ($this->translator->getSnippetSetId() !== null) {
  402.             return false;
  403.         }
  405.         $this->translator->injectSettings(
  406.             $salesChannelId,
  407.             $context->getLanguageId(),
  408.             $this->languageLocaleProvider->getLocaleForLanguageId($context->getLanguageId()),
  409.             $context
  410.         );
  412.         return true;
  413.     }
  415.     /**
  416.      * @param array<string, mixed> $recipients
  417.      * @param array<string, mixed> $mailStructRecipients
  418.      * @param array<int|string, mixed> $contactFormData
  419.      *
  420.      * @return array<int|string, string>
  421.      */
  422.     private function getRecipients(array $recipients, array $mailStructRecipients, array $contactFormData): array
  423.     {
  424.         switch ($recipients['type']) {
  425.             case self::RECIPIENT_CONFIG_CUSTOM:
  426.                 return $recipients['data'];
  427.             case self::RECIPIENT_CONFIG_ADMIN:
  428.                 $admins = $this->connection->fetchAllAssociative(
  429.                     'SELECT first_name, last_name, email FROM user WHERE admin = true'
  430.                 );
  431.                 $emails = [];
  432.                 foreach ($admins as $admin) {
  433.                     $emails[$admin['email']] = $admin['first_name'] . ' ' . $admin['last_name'];
  434.                 }
  436.                 return $emails;
  437.             case self::RECIPIENT_CONFIG_CONTACT_FORM_MAIL:
  438.                 if (empty($contactFormData)) {
  439.                     return [];
  440.                 }
  442.                 if (!\array_key_exists('email', $contactFormData)) {
  443.                     return [];
  444.                 }
  446.                 return [$contactFormData['email'] => ($contactFormData['firstName'] ?? '') . ' ' . ($contactFormData['lastName'] ?? '')];
  447.             default:
  448.                 return $mailStructRecipients;
  449.         }
  450.     }
  452.     /**
  453.      * @param array<string> $documentIds
  454.      * @param array<mixed, mixed> $attachments
  455.      *
  456.      * @return array<mixed, mixed>
  457.      */
  458.     private function buildOrderAttachments(array $documentIds, array $attachments, Context $context): array
  459.     {
  460.         $criteria = new Criteria($documentIds);
  461.         $criteria->setTitle('send-mail::load-attachments');
  462.         $criteria->addAssociation('documentMediaFile');
  463.         $criteria->addAssociation('documentType');
  465.         /** @var DocumentCollection $documents */
  466.         $documents = $this->documentRepository->search($criteria, $context)->getEntities();
  468.         return $this->mappingAttachmentsInfo($documents, $attachments, $context);
  469.     }
  471.     /**
  472.      * @param array<string> $documentTypeIds
  473.      *
  474.      * @return array<string>
  475.      */
  476.     private function getLatestDocumentsOfTypes(string $orderId, array $documentTypeIds): array
  477.     {
  478.         $documents = $this->connection->fetchAllAssociative(
  479.             'SELECT
  480.                 LOWER(hex(`document`.`document_type_id`)) as doc_type,
  481.                 LOWER(hex(`document`.`id`)) as doc_id,
  482.                 `document`.`created_at` as newest_date
  483.             FROM
  484.                 `document`
  485.             WHERE
  486.                 HEX(`document`.`order_id`) = :orderId
  487.                 AND HEX(`document`.`document_type_id`) IN (:documentTypeIds)
  488.             ORDER BY `document`.`created_at` DESC',
  489.             [
  490.                 'orderId' => $orderId,
  491.                 'documentTypeIds' => $documentTypeIds,
  492.             ],
  493.             [
  494.                 'documentTypeIds' => Connection::PARAM_STR_ARRAY,
  495.             ]
  496.         );
  498.         $documentsGroupByType = FetchModeHelper::group($documents);
  500.         $documentIds = [];
  502.         foreach ($documentsGroupByType as $document) {
  503.             $documentIds[] = array_shift($document)['doc_id'];
  504.         }
  506.         return $documentIds;
  507.     }
  509.     /**
  510.      * @param array<mixed, mixed> $attachments
  511.      *
  512.      * @return array<mixed, mixed>
  513.      */
  514.     private function mappingAttachmentsInfo(DocumentCollection $documents, array $attachments, Context $context): array
  515.     {
  516.         foreach ($documents as $document) {
  517.             $documentId = $document->getId();
  518.             $document = $this->documentService->getDocument($document, $context);
  520.             $attachments[] = [
  521.                 'id' => $documentId,
  522.                 'content' => $document->getFileBlob(),
  523.                 'fileName' => $document->getFilename(),
  524.                 'mimeType' => $document->getContentType(),
  525.             ];
  526.         }
  528.         return $attachments;
  529.     }
  531.     /**
  532.      * @param array<string> $documentIds
  533.      * @param array<mixed, mixed> $attachments
  534.      *
  535.      * @return array<mixed, mixed>
  536.      */
  537.     private function mappingAttachments(array $documentIds, array $attachments, Context $context): array
  538.     {
  539.         foreach ($documentIds as $documentId) {
  540.             $document = $this->documentGenerator->readDocument($documentId, $context);
  542.             if ($document === null) {
  543.                 continue;
  544.             }
  546.             $attachments[] = [
  547.                 'id' => $documentId,
  548.                 'content' => $document->getContent(),
  549.                 'fileName' => $document->getName(),
  550.                 'mimeType' => $document->getContentType(),
  551.             ];
  552.         }
  554.         return $attachments;
  555.     }
  556. }