src/Service/EmailService.php line 207

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Service;
  7. use App\Exception\ApiException\ApiEmailSearchException;
  8. use App\Exception\ApiException\ApiEmailSendException;
  9. use App\Exception\ApiException\ApiValidationException;
  10. use App\Exception\ApiException\NotFoundException;
  11. use App\Exception\ApiException\SendGridApiException;
  12. use App\Model\Email;
  13. use App\Validator\TemplatePath;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  16. use Symfony\Component\HttpKernel\KernelInterface;
  17. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  18. use Symfony\Component\Mailer\MailerInterface;
  19. use Symfony\Component\Mime\Address;
  20. use Symfony\Component\Mime\BodyRendererInterface;
  21. use Symfony\Component\Translation\Translator;
  22. use Symfony\Component\Validator\Validator\ValidatorInterface;
  23. use Symfony\Contracts\Translation\TranslatorInterface;
  24. use Twig\Environment;
  26. class EmailService
  27. {
  28.     /** @var LoggerInterface */
  29.     protected $log;
  30.     /** @var MailerInterface */
  31.     private $mailer;
  32.     /** @var Translator */
  33.     private $translator;
  34.     /** @var BodyRendererInterface */
  35.     private $bodyRenderer;
  36.     /** @var ValidatorInterface */
  37.     private $validator;
  38.     /** @var Environment */
  39.     private $twig;
  40.     /** @var KernelInterface */
  41.     private $kernel;
  42.     /** @var SendGridApi */
  43.     private $sendGridApi;
  45.     public function __construct(
  46.         LoggerInterface $log,
  47.         MailerInterface $mailer,
  48.         TranslatorInterface $translator,
  49.         BodyRendererInterface $bodyRenderer,
  50.         ValidatorInterface $validator,
  51.         Environment $twig,
  52.         KernelInterface $kernel,
  53.         SendGridApi $sendGridApi
  54.     ) {
  55.         $this->log = $log;
  56.         $this->mailer = $mailer;
  57.         $this->translator = $translator;
  58.         $this->bodyRenderer = $bodyRenderer;
  59.         $this->validator = $validator;
  60.         $this->twig = $twig;
  61.         $this->kernel = $kernel;
  62.         $this->sendGridApi = $sendGridApi;
  63.     }
  65.     /**
  66.      * @param TemplatedEmail $templatedEmail
  67.      * @throws ApiEmailSendException
  68.      */
  69.     public function send(TemplatedEmail $templatedEmail): void
  70.     {
  71.         try {
  72.             $this->mailer->send($templatedEmail);
  73.         } catch (TransportExceptionInterface $e) {
  74.             $this->log->error(get_class($e).' - '.$e->getMessage());
  75.             throw new ApiEmailSendException($e->getMessage());
  76.         }
  77.     }
  79.     /**
  80.      * @param string $query
  81.      * @param int    $limit
  82.      *
  83.      * @return array
  84.      * @throws ApiEmailSearchException
  85.      */
  86.     public function findMessagesByQuery(string $query, int $limit = 0): array
  87.     {
  88.         try {
  89.             if ($limit > 0 && $limit <= SendGridApi::FIND_MESSAGES_MAX_LIMIT) {
  90.                 return $this->sendGridApi->findMessagesByQuery($query, $limit);
  91.             }
  93.             // init first batch
  94.             $messages = $messagesId = [];
  95.             $batchQuery = $query;
  96.             $batchCpt = 0;
  98.             do {
  99.                 ++$batchCpt;
  100.                 // messages recovery for current batch
  101.                 $tmpMessages = [];
  103.                 // get messages for current batch
  104.                 $this->log->info(sprintf(
  105.                     'Batch #%d: Try to get %d messages by API (%d already recovered)...',
  106.                     $batchCpt,
  107.                     SendGridApi::FIND_MESSAGES_MAX_LIMIT,
  108.                     count($messages),
  109.                 ));
  110.                 $this->log->debug(sprintf(
  111.                     'Batch #%d: limit = %d, query = %s...',
  112.                     $batchCpt,
  113.                     $limit,
  114.                     $batchQuery,
  115.                 ));
  117.                 $batchMessages = $this->sendGridApi->findMessagesByQuery($batchQuery, SendGridApi::FIND_MESSAGES_MAX_LIMIT);
  119.                 $this->log->debug(sprintf(
  120.                     'Batch #%d: %d messages recovered by API.',
  121.                     $batchCpt,
  122.                     count($batchMessages),
  123.                 ));
  125.                 // filter messages already recovery by previous batch
  126.                 foreach ($batchMessages as $batchMessage) {
  127.                     if (in_array($batchMessage['msg_id'], $messagesId)) {
  128.                         continue;
  129.                     }
  131.                     $messagesId[] = $batchMessage['msg_id'];
  132.                     $tmpMessages[] = $batchMessage;
  133.                 }
  135.                 $this->log->debug(sprintf(
  136.                     'Batch #%d: %d messages after remove duplicate messages.',
  137.                     $batchCpt,
  138.                     count($tmpMessages),
  139.                 ));
  141.                 // finish here if no new messages recovered. Avoid infinite loop
  142.                 if (!$tmpMessages) {
  143.                     $this->log->debug(sprintf('Batch #%d: [STOP] No new messages recovered', $batchCpt));
  144.                     break;
  145.                 }
  147.                 // determine period for next batch, by last event time.
  148.                 // Messages return by API sorted by last event time in descending order
  150.                 $batchPeriodEnd = $tmpMessages[array_key_last($tmpMessages)]['last_event_time'];
  151.                 $batchPeriodStart = (new \DateTime($batchPeriodEnd))->modify('-1 month')->format(\DateTime::ATOM);
  153.                 // build query for next batch
  154.                 $batchQuery = 'last_event_time BETWEEN TIMESTAMP "'.$batchPeriodStart.'" AND TIMESTAMP "'.$batchPeriodEnd.'"';
  155.                 if ($query) {
  156.                     $batchQuery = $query.' AND '.$batchQuery;
  157.                 }
  159.                 $messages = array_merge($messages, $tmpMessages);
  160.                 if ($limit > 0 && count($messages) >= $limit) {
  161.                     $this->log->debug(sprintf('Batch #%d: [STOP] Message limit is reached', $batchCpt));
  162.                     $messages = array_slice($messages, 0, $limit);
  163.                     break;
  164.                 }
  165.             } while (SendGridApi::FIND_MESSAGES_MAX_LIMIT === count($batchMessages));
  167.             $this->log->info(sprintf(
  168.                 '[OK] %d messages recovered by API in %d batch',
  169.                 count($messages),
  170.                 $batchCpt,
  171.             ));
  173.             return $messages;
  174.         } catch (SendGridApiException $e) {
  175.             $this->log->error(get_class($e).' - '.$e->getMessage());
  176.             throw new ApiEmailSearchException($e->getMessage());
  177.         }
  178.     }
  180.     /**
  181.      * @param string $messageId
  182.      *
  183.      * @return array
  184.      * @throws ApiEmailSearchException
  185.      * @throws NotFoundException
  186.      */
  187.     public function findMessageById(string $messageId): array
  188.     {
  189.         try {
  190.             return $this->sendGridApi->findMessageById($messageId);
  191.         } catch (SendGridApiException $e) {
  192.             $this->log->error(get_class($e).' - '.$e->getMessage());
  193.             throw new ApiEmailSearchException($e->getMessage());
  194.         }
  195.     }
  197.     /**
  198.      * @param Email $email
  199.      * @return TemplatedEmail
  200.      * @throws ApiValidationException
  201.      * @throws \Twig\Error\LoaderError
  202.      * @throws \Twig\Error\RuntimeError
  203.      * @throws \Twig\Error\SyntaxError
  204.      */
  205.     public function generateTemplatedEmail(Email $email): TemplatedEmail
  206.     {
  207.         $errors = $this->validator->validate($email);
  208.         if (count($errors) > 0) {
  209.             throw new ApiValidationException($errors);
  210.         }
  212.         $templatedEmail = (new TemplatedEmail())
  213.             ->from($this->buildFromAddress($email->getFrom(), $email->getFromName()))
  214.             ->to(...Address::createArray($email->getTo()))
  215.             ->htmlTemplate(TemplatePath::getTemplateRealPath($email->getTemplatePath()))
  216.             ->context(array_merge($email->getTemplateData(), ['email_locale' => $email->getLocale()]));
  218.         if (is_array($email->getCc())) {
  219.             $templatedEmail->cc(...Address::createArray($email->getCc()));
  220.         }
  222.         if (is_array($email->getBcc())) {
  223.             $templatedEmail->bcc(...Address::createArray($email->getBcc()));
  224.         }
  226.         if (is_array($email->getReply())) {
  227.             $templatedEmail->replyTo(...Address::createArray($email->getReply()));
  228.         }
  230.         $attachments = $email->getAttachments();
  231.         if (is_array($attachments)) {
  232.             foreach ($attachments as $attachment) {
  233.                 $fileString = base64_decode($attachment['content']);
  234.                 $templatedEmail->attach($fileString, $attachment['filename'], $attachment['contentType']);
  235.             }
  236.         }
  238.         // Set locale for email template rendering
  239.         $originalLocale = $this->translator->getLocale();
  240.         if (!is_null($email->getLocale())) {
  241.             $this->translator->setLocale($email->getLocale());
  242.         }
  244.         // Set default email subject
  245.         if (is_null($email->getSubject())) {
  246.             $subject = trim($this->twig->render(
  247.                 TemplatePath::getSubjectTemplateRealPath($email->getTemplatePath()),
  248.                 $email->getTemplateData()
  249.             ));
  250.             $templatedEmail->subject($subject);
  251.         } else {
  252.             $templatedEmail->subject($email->getSubject());
  253.         }
  255.         // Render email
  256.         $this->bodyRenderer->render($templatedEmail);
  258.         // Reset locale
  259.         $this->translator->setLocale($originalLocale);
  261.         return $templatedEmail;
  262.     }
  264.     /**
  265.      * @param string $from
  266.      * @param string $fromName
  267.      * @return Address
  268.      * @throws \Exception
  269.      */
  270.     private function buildFromAddress(string $from, string $fromName): Address
  271.     {
  272.         switch ($this->kernel->getEnvironment()) {
  273.             case 'prod':
  274.                 return new Address("$from@hipay.com", $fromName);
  275.             case 'stage':
  276.                 return new Address("$from@stage.hipay.com", "$fromName STAGE");
  277.             case 'qa':
  278.                 return new Address("$from@qa.hipay.com", "$fromName QA");
  279.             case 'test':
  280.                 return new Address("$from@test.hipay.com", "$fromName TEST");
  281.             case 'dev':
  282.             case 'devgcp':
  283.                 return new Address("$from@dev.hipay.com", "$fromName DEV");
  284.             default:
  285.                 throw new \Exception('Unsuppported environment');
  286.         }
  287.     }
  288. }