vendor/symfony/mime/Email.php line 25

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Mime;
  14. use Symfony\Component\Mime\Exception\LogicException;
  15. use Symfony\Component\Mime\Part\AbstractPart;
  16. use Symfony\Component\Mime\Part\DataPart;
  17. use Symfony\Component\Mime\Part\Multipart\AlternativePart;
  18. use Symfony\Component\Mime\Part\Multipart\MixedPart;
  19. use Symfony\Component\Mime\Part\Multipart\RelatedPart;
  20. use Symfony\Component\Mime\Part\TextPart;
  22. /**
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  */
  25. class Email extends Message
  26. {
  27.     public const PRIORITY_HIGHEST = 1;
  28.     public const PRIORITY_HIGH = 2;
  29.     public const PRIORITY_NORMAL = 3;
  30.     public const PRIORITY_LOW = 4;
  31.     public const PRIORITY_LOWEST = 5;
  33.     private const PRIORITY_MAP = [
  34.         self::PRIORITY_HIGHEST => 'Highest',
  35.         self::PRIORITY_HIGH => 'High',
  36.         self::PRIORITY_NORMAL => 'Normal',
  37.         self::PRIORITY_LOW => 'Low',
  38.         self::PRIORITY_LOWEST => 'Lowest',
  39.     ];
  41.     /**
  42.      * @var resource|string|null
  43.      */
  44.     private $text;
  46.     private ?string $textCharset = null;
  48.     /**
  49.      * @var resource|string|null
  50.      */
  51.     private $html;
  53.     private ?string $htmlCharset = null;
  54.     private array $attachments = [];
  55.     private ?AbstractPart $cachedBody = null; // Used to avoid wrong body hash in DKIM signatures with multiple parts (e.g. HTML + TEXT) due to multiple boundaries.
  57.     /**
  58.      * @return $this
  59.      */
  60.     public function subject(string $subject): static
  61.     {
  62.         return $this->setHeaderBody('Text', 'Subject', $subject);
  63.     }
  65.     public function getSubject(): ?string
  66.     {
  67.         return $this->getHeaders()->getHeaderBody('Subject');
  68.     }
  70.     /**
  71.      * @return $this
  72.      */
  73.     public function date(\DateTimeInterface $dateTime): static
  74.     {
  75.         return $this->setHeaderBody('Date', 'Date', $dateTime);
  76.     }
  78.     public function getDate(): ?\DateTimeImmutable
  79.     {
  80.         return $this->getHeaders()->getHeaderBody('Date');
  81.     }
  83.     /**
  84.      * @return $this
  85.      */
  86.     public function returnPath(Address|string $address): static
  87.     {
  88.         return $this->setHeaderBody('Path', 'Return-Path', Address::create($address));
  89.     }
  91.     public function getReturnPath(): ?Address
  92.     {
  93.         return $this->getHeaders()->getHeaderBody('Return-Path');
  94.     }
  96.     /**
  97.      * @return $this
  98.      */
  99.     public function sender(Address|string $address): static
  100.     {
  101.         return $this->setHeaderBody('Mailbox', 'Sender', Address::create($address));
  102.     }
  104.     public function getSender(): ?Address
  105.     {
  106.         return $this->getHeaders()->getHeaderBody('Sender');
  107.     }
  109.     /**
  110.      * @return $this
  111.      */
  112.     public function addFrom(Address|string ...$addresses): static
  113.     {
  114.         return $this->addListAddressHeaderBody('From', $addresses);
  115.     }
  117.     /**
  118.      * @return $this
  119.      */
  120.     public function from(Address|string ...$addresses): static
  121.     {
  122.         return $this->setListAddressHeaderBody('From', $addresses);
  123.     }
  125.     /**
  126.      * @return Address[]
  127.      */
  128.     public function getFrom(): array
  129.     {
  130.         return $this->getHeaders()->getHeaderBody('From') ?: [];
  131.     }
  133.     /**
  134.      * @return $this
  135.      */
  136.     public function addReplyTo(Address|string ...$addresses): static
  137.     {
  138.         return $this->addListAddressHeaderBody('Reply-To', $addresses);
  139.     }
  141.     /**
  142.      * @return $this
  143.      */
  144.     public function replyTo(Address|string ...$addresses): static
  145.     {
  146.         return $this->setListAddressHeaderBody('Reply-To', $addresses);
  147.     }
  149.     /**
  150.      * @return Address[]
  151.      */
  152.     public function getReplyTo(): array
  153.     {
  154.         return $this->getHeaders()->getHeaderBody('Reply-To') ?: [];
  155.     }
  157.     /**
  158.      * @return $this
  159.      */
  160.     public function addTo(Address|string ...$addresses): static
  161.     {
  162.         return $this->addListAddressHeaderBody('To', $addresses);
  163.     }
  165.     /**
  166.      * @return $this
  167.      */
  168.     public function to(Address|string ...$addresses): static
  169.     {
  170.         return $this->setListAddressHeaderBody('To', $addresses);
  171.     }
  173.     /**
  174.      * @return Address[]
  175.      */
  176.     public function getTo(): array
  177.     {
  178.         return $this->getHeaders()->getHeaderBody('To') ?: [];
  179.     }
  181.     /**
  182.      * @return $this
  183.      */
  184.     public function addCc(Address|string ...$addresses): static
  185.     {
  186.         return $this->addListAddressHeaderBody('Cc', $addresses);
  187.     }
  189.     /**
  190.      * @return $this
  191.      */
  192.     public function cc(Address|string ...$addresses): static
  193.     {
  194.         return $this->setListAddressHeaderBody('Cc', $addresses);
  195.     }
  197.     /**
  198.      * @return Address[]
  199.      */
  200.     public function getCc(): array
  201.     {
  202.         return $this->getHeaders()->getHeaderBody('Cc') ?: [];
  203.     }
  205.     /**
  206.      * @return $this
  207.      */
  208.     public function addBcc(Address|string ...$addresses): static
  209.     {
  210.         return $this->addListAddressHeaderBody('Bcc', $addresses);
  211.     }
  213.     /**
  214.      * @return $this
  215.      */
  216.     public function bcc(Address|string ...$addresses): static
  217.     {
  218.         return $this->setListAddressHeaderBody('Bcc', $addresses);
  219.     }
  221.     /**
  222.      * @return Address[]
  223.      */
  224.     public function getBcc(): array
  225.     {
  226.         return $this->getHeaders()->getHeaderBody('Bcc') ?: [];
  227.     }
  229.     /**
  230.      * Sets the priority of this message.
  231.      *
  232.      * The value is an integer where 1 is the highest priority and 5 is the lowest.
  233.      *
  234.      * @return $this
  235.      */
  236.     public function priority(int $priority): static
  237.     {
  238.         if ($priority > 5) {
  239.             $priority = 5;
  240.         } elseif ($priority < 1) {
  241.             $priority = 1;
  242.         }
  244.         return $this->setHeaderBody('Text', 'X-Priority', sprintf('%d (%s)', $priority, self::PRIORITY_MAP[$priority]));
  245.     }
  247.     /**
  248.      * Get the priority of this message.
  249.      *
  250.      * The returned value is an integer where 1 is the highest priority and 5
  251.      * is the lowest.
  252.      */
  253.     public function getPriority(): int
  254.     {
  255.         [$priority] = sscanf($this->getHeaders()->getHeaderBody('X-Priority') ?? '', '%[1-5]');
  257.         return $priority ?? 3;
  258.     }
  260.     /**
  261.      * @param resource|string|null $body
  262.      *
  263.      * @return $this
  264.      */
  265.     public function text($body, string $charset = 'utf-8'): static
  266.     {
  267.         if (null !== $body && !\is_string($body) && !\is_resource($body)) {
  268.             throw new \TypeError(sprintf('The body must be a string, a resource or null (got "%s").', get_debug_type($body)));
  269.         }
  271.         $this->cachedBody = null;
  272.         $this->text = $body;
  273.         $this->textCharset = $charset;
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return resource|string|null
  280.      */
  281.     public function getTextBody()
  282.     {
  283.         return $this->text;
  284.     }
  286.     public function getTextCharset(): ?string
  287.     {
  288.         return $this->textCharset;
  289.     }
  291.     /**
  292.      * @param resource|string|null $body
  293.      *
  294.      * @return $this
  295.      */
  296.     public function html($body, string $charset = 'utf-8'): static
  297.     {
  298.         if (null !== $body && !\is_string($body) && !\is_resource($body)) {
  299.             throw new \TypeError(sprintf('The body must be a string, a resource or null (got "%s").', get_debug_type($body)));
  300.         }
  302.         $this->cachedBody = null;
  303.         $this->html = $body;
  304.         $this->htmlCharset = $charset;
  306.         return $this;
  307.     }
  309.     /**
  310.      * @return resource|string|null
  311.      */
  312.     public function getHtmlBody()
  313.     {
  314.         return $this->html;
  315.     }
  317.     public function getHtmlCharset(): ?string
  318.     {
  319.         return $this->htmlCharset;
  320.     }
  322.     /**
  323.      * @param resource|string $body
  324.      *
  325.      * @return $this
  326.      */
  327.     public function attach($body, string $name = null, string $contentType = null): static
  328.     {
  329.         if (!\is_string($body) && !\is_resource($body)) {
  330.             throw new \TypeError(sprintf('The body must be a string or a resource (got "%s").', get_debug_type($body)));
  331.         }
  333.         $this->cachedBody = null;
  334.         $this->attachments[] = ['body' => $body, 'name' => $name, 'content-type' => $contentType, 'inline' => false];
  336.         return $this;
  337.     }
  339.     /**
  340.      * @return $this
  341.      */
  342.     public function attachFromPath(string $path, string $name = null, string $contentType = null): static
  343.     {
  344.         $this->cachedBody = null;
  345.         $this->attachments[] = ['path' => $path, 'name' => $name, 'content-type' => $contentType, 'inline' => false];
  347.         return $this;
  348.     }
  350.     /**
  351.      * @param resource|string $body
  352.      *
  353.      * @return $this
  354.      */
  355.     public function embed($body, string $name = null, string $contentType = null): static
  356.     {
  357.         if (!\is_string($body) && !\is_resource($body)) {
  358.             throw new \TypeError(sprintf('The body must be a string or a resource (got "%s").', get_debug_type($body)));
  359.         }
  361.         $this->cachedBody = null;
  362.         $this->attachments[] = ['body' => $body, 'name' => $name, 'content-type' => $contentType, 'inline' => true];
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return $this
  369.      */
  370.     public function embedFromPath(string $path, string $name = null, string $contentType = null): static
  371.     {
  372.         $this->cachedBody = null;
  373.         $this->attachments[] = ['path' => $path, 'name' => $name, 'content-type' => $contentType, 'inline' => true];
  375.         return $this;
  376.     }
  378.     /**
  379.      * @return $this
  380.      */
  381.     public function attachPart(DataPart $part): static
  382.     {
  383.         $this->cachedBody = null;
  384.         $this->attachments[] = ['part' => $part];
  386.         return $this;
  387.     }
  389.     /**
  390.      * @return array|DataPart[]
  391.      */
  392.     public function getAttachments(): array
  393.     {
  394.         $parts = [];
  395.         foreach ($this->attachments as $attachment) {
  396.             $parts[] = $this->createDataPart($attachment);
  397.         }
  399.         return $parts;
  400.     }
  402.     public function getBody(): AbstractPart
  403.     {
  404.         if (null !== $body = parent::getBody()) {
  405.             return $body;
  406.         }
  408.         return $this->generateBody();
  409.     }
  411.     public function ensureValidity()
  412.     {
  413.         $this->ensureBodyValid();
  415.         if ('1' === $this->getHeaders()->getHeaderBody('X-Unsent')) {
  416.             throw new LogicException('Cannot send messages marked as "draft".');
  417.         }
  419.         parent::ensureValidity();
  420.     }
  422.     private function ensureBodyValid(): void
  423.     {
  424.         if (null === $this->text && null === $this->html && !$this->attachments) {
  425.             throw new LogicException('A message must have a text or an HTML part or attachments.');
  426.         }
  427.     }
  429.     /**
  430.      * Generates an AbstractPart based on the raw body of a message.
  431.      *
  432.      * The most "complex" part generated by this method is when there is text and HTML bodies
  433.      * with related images for the HTML part and some attachments:
  434.      *
  435.      * multipart/mixed
  436.      *         |
  437.      *         |------------> multipart/related
  438.      *         |                      |
  439.      *         |                      |------------> multipart/alternative
  440.      *         |                      |                      |
  441.      *         |                      |                       ------------> text/plain (with content)
  442.      *         |                      |                      |
  443.      *         |                      |                       ------------> text/html (with content)
  444.      *         |                      |
  445.      *         |                       ------------> image/png (with content)
  446.      *         |
  447.      *          ------------> application/pdf (with content)
  448.      */
  449.     private function generateBody(): AbstractPart
  450.     {
  451.         if (null !== $this->cachedBody) {
  452.             return $this->cachedBody;
  453.         }
  455.         $this->ensureBodyValid();
  457.         [$htmlPart, $attachmentParts, $inlineParts] = $this->prepareParts();
  459.         $part = null === $this->text ? null : new TextPart($this->text, $this->textCharset);
  460.         if (null !== $htmlPart) {
  461.             if (null !== $part) {
  462.                 $part = new AlternativePart($part, $htmlPart);
  463.             } else {
  464.                 $part = $htmlPart;
  465.             }
  466.         }
  468.         if ($inlineParts) {
  469.             $part = new RelatedPart($part, ...$inlineParts);
  470.         }
  472.         if ($attachmentParts) {
  473.             if ($part) {
  474.                 $part = new MixedPart($part, ...$attachmentParts);
  475.             } else {
  476.                 $part = new MixedPart(...$attachmentParts);
  477.             }
  478.         }
  480.         return $this->cachedBody = $part;
  481.     }
  483.     private function prepareParts(): ?array
  484.     {
  485.         $names = [];
  486.         $htmlPart = null;
  487.         $html = $this->html;
  488.         if (null !== $html) {
  489.             $htmlPart = new TextPart($html, $this->htmlCharset, 'html');
  490.             $html = $htmlPart->getBody();
  492.             $regexes = [
  493.                 '<img\s+[^>]*src\s*=\s*(?:([\'"])cid:(.+?)\\1|cid:([^>\s]+))',
  494.                 '<\w+\s+[^>]*background\s*=\s*(?:([\'"])cid:(.+?)\\1|cid:([^>\s]+))',
  495.             ];
  496.             $tmpMatches = [];
  497.             foreach ($regexes as $regex) {
  498.                 preg_match_all('/'.$regex.'/i', $html, $tmpMatches);
  499.                 $names = array_merge($names, $tmpMatches[2], $tmpMatches[3]);
  500.             }
  501.             $names = array_filter(array_unique($names));
  502.         }
  504.         // usage of reflection is a temporary workaround for missing getters that will be added in 6.2
  505.         $dispositionRef = new \ReflectionProperty(TextPart::class, 'disposition');
  506.         $dispositionRef->setAccessible(true);
  507.         $nameRef = new \ReflectionProperty(TextPart::class, 'name');
  508.         $nameRef->setAccessible(true);
  509.         $attachmentParts = $inlineParts = [];
  510.         foreach ($this->attachments as $attachment) {
  511.             $part = $this->createDataPart($attachment);
  512.             if (isset($attachment['part'])) {
  513.                 $attachment['name'] = $nameRef->getValue($part);
  514.             }
  516.             foreach ($names as $name) {
  517.                 if ($name !== $attachment['name']) {
  518.                     continue;
  519.                 }
  520.                 if (isset($inlineParts[$name])) {
  521.                     continue 2;
  522.                 }
  523.                 $part->setDisposition('inline');
  524.                 $html = str_replace('cid:'.$name, 'cid:'.$part->getContentId(), $html);
  525.                 $part->setName($part->getContentId());
  527.                 break;
  528.             }
  530.             if ('inline' === $dispositionRef->getValue($part)) {
  531.                 $inlineParts[$attachment['name']] = $part;
  532.             } else {
  533.                 $attachmentParts[] = $part;
  534.             }
  535.         }
  536.         if (null !== $htmlPart) {
  537.             $htmlPart = new TextPart($html, $this->htmlCharset, 'html');
  538.         }
  540.         return [$htmlPart, $attachmentParts, array_values($inlineParts)];
  541.     }
  543.     private function createDataPart(array $attachment): DataPart
  544.     {
  545.         if (isset($attachment['part'])) {
  546.             return $attachment['part'];
  547.         }
  549.         if (isset($attachment['body'])) {
  550.             $part = new DataPart($attachment['body'], $attachment['name'] ?? null, $attachment['content-type'] ?? null);
  551.         } else {
  552.             $part = DataPart::fromPath($attachment['path'] ?? '', $attachment['name'] ?? null, $attachment['content-type'] ?? null);
  553.         }
  554.         if ($attachment['inline']) {
  555.             $part->asInline();
  556.         }
  558.         return $part;
  559.     }
  561.     /**
  562.      * @return $this
  563.      */
  564.     private function setHeaderBody(string $type, string $name, $body): static
  565.     {
  566.         $this->getHeaders()->setHeaderBody($type, $name, $body);
  568.         return $this;
  569.     }
  571.     private function addListAddressHeaderBody(string $name, array $addresses)
  572.     {
  573.         if (!$header = $this->getHeaders()->get($name)) {
  574.             return $this->setListAddressHeaderBody($name, $addresses);
  575.         }
  576.         $header->addAddresses(Address::createArray($addresses));
  578.         return $this;
  579.     }
  581.     /**
  582.      * @return $this
  583.      */
  584.     private function setListAddressHeaderBody(string $name, array $addresses): static
  585.     {
  586.         $addresses = Address::createArray($addresses);
  587.         $headers = $this->getHeaders();
  588.         if ($header = $headers->get($name)) {
  589.             $header->setAddresses($addresses);
  590.         } else {
  591.             $headers->addMailboxListHeader($name, $addresses);
  592.         }
  594.         return $this;
  595.     }
  597.     /**
  598.      * @internal
  599.      */
  600.     public function __serialize(): array
  601.     {
  602.         if (\is_resource($this->text)) {
  603.             $this->text = (new TextPart($this->text))->getBody();
  604.         }
  606.         if (\is_resource($this->html)) {
  607.             $this->html = (new TextPart($this->html))->getBody();
  608.         }
  610.         foreach ($this->attachments as $i => $attachment) {
  611.             if (isset($attachment['body']) && \is_resource($attachment['body'])) {
  612.                 $this->attachments[$i]['body'] = (new TextPart($attachment['body']))->getBody();
  613.             }
  614.         }
  616.         return [$this->text, $this->textCharset, $this->html, $this->htmlCharset, $this->attachments, parent::__serialize()];
  617.     }
  619.     /**
  620.      * @internal
  621.      */
  622.     public function __unserialize(array $data): void
  623.     {
  624.         [$this->text, $this->textCharset, $this->html, $this->htmlCharset, $this->attachments, $parentData] = $data;
  626.         parent::__unserialize($parentData);
  627.     }
  628. }