vendor/swiftmailer/swiftmailer/lib/classes/Swift/Mime/SimpleMessage.php line 323

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of SwiftMailer.
  5.  * (c) 2004-2009 Chris Corbyn
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  11. /**
  12.  * The default email message class.
  13.  *
  14.  * @author Chris Corbyn
  15.  */
  16. class Swift_Mime_SimpleMessage extends Swift_Mime_MimePart
  17. {
  18.     const PRIORITY_HIGHEST = 1;
  19.     const PRIORITY_HIGH = 2;
  20.     const PRIORITY_NORMAL = 3;
  21.     const PRIORITY_LOW = 4;
  22.     const PRIORITY_LOWEST = 5;
  24.     /**
  25.      * Create a new SimpleMessage with $headers, $encoder and $cache.
  26.      *
  27.      * @param string $charset
  28.      */
  29.     public function __construct(Swift_Mime_SimpleHeaderSet $headers, Swift_Mime_ContentEncoder $encoder, Swift_KeyCache $cache, Swift_IdGenerator $idGenerator, $charset = null)
  30.     {
  31.         parent::__construct($headers, $encoder, $cache, $idGenerator, $charset);
  32.         $this->getHeaders()->defineOrdering([
  33.             'Return-Path',
  34.             'Received',
  35.             'DKIM-Signature',
  36.             'DomainKey-Signature',
  37.             'Sender',
  38.             'Message-ID',
  39.             'Date',
  40.             'Subject',
  41.             'From',
  42.             'Reply-To',
  43.             'To',
  44.             'Cc',
  45.             'Bcc',
  46.             'MIME-Version',
  47.             'Content-Type',
  48.             'Content-Transfer-Encoding',
  49.             ]);
  50.         $this->getHeaders()->setAlwaysDisplayed(['Date', 'Message-ID', 'From']);
  51.         $this->getHeaders()->addTextHeader('MIME-Version', '1.0');
  52.         $this->setDate(new DateTimeImmutable());
  53.         $this->setId($this->getId());
  54.         $this->getHeaders()->addMailboxHeader('From');
  55.     }
  57.     /**
  58.      * Always returns {@link LEVEL_TOP} for a message instance.
  59.      *
  60.      * @return int
  61.      */
  62.     public function getNestingLevel()
  63.     {
  64.         return self::LEVEL_TOP;
  65.     }
  67.     /**
  68.      * Set the subject of this message.
  69.      *
  70.      * @param string $subject
  71.      *
  72.      * @return $this
  73.      */
  74.     public function setSubject($subject)
  75.     {
  76.         if (!$this->setHeaderFieldModel('Subject', $subject)) {
  77.             $this->getHeaders()->addTextHeader('Subject', $subject);
  78.         }
  80.         return $this;
  81.     }
  83.     /**
  84.      * Get the subject of this message.
  85.      *
  86.      * @return string
  87.      */
  88.     public function getSubject()
  89.     {
  90.         return $this->getHeaderFieldModel('Subject');
  91.     }
  93.     /**
  94.      * Set the date at which this message was created.
  95.      *
  96.      * @return $this
  97.      */
  98.     public function setDate(DateTimeInterface $dateTime)
  99.     {
  100.         if (!$this->setHeaderFieldModel('Date', $dateTime)) {
  101.             $this->getHeaders()->addDateHeader('Date', $dateTime);
  102.         }
  104.         return $this;
  105.     }
  107.     /**
  108.      * Get the date at which this message was created.
  109.      *
  110.      * @return DateTimeInterface
  111.      */
  112.     public function getDate()
  113.     {
  114.         return $this->getHeaderFieldModel('Date');
  115.     }
  117.     /**
  118.      * Set the return-path (the bounce address) of this message.
  119.      *
  120.      * @param string $address
  121.      *
  122.      * @return $this
  123.      */
  124.     public function setReturnPath($address)
  125.     {
  126.         if (!$this->setHeaderFieldModel('Return-Path', $address)) {
  127.             $this->getHeaders()->addPathHeader('Return-Path', $address);
  128.         }
  130.         return $this;
  131.     }
  133.     /**
  134.      * Get the return-path (bounce address) of this message.
  135.      *
  136.      * @return string
  137.      */
  138.     public function getReturnPath()
  139.     {
  140.         return $this->getHeaderFieldModel('Return-Path');
  141.     }
  143.     /**
  144.      * Set the sender of this message.
  145.      *
  146.      * This does not override the From field, but it has a higher significance.
  147.      *
  148.      * @param string $address
  149.      * @param string $name    optional
  150.      *
  151.      * @return $this
  152.      */
  153.     public function setSender($address, $name = null)
  154.     {
  155.         if (!is_array($address) && isset($name)) {
  156.             $address = [$address => $name];
  157.         }
  159.         if (!$this->setHeaderFieldModel('Sender', (array) $address)) {
  160.             $this->getHeaders()->addMailboxHeader('Sender', (array) $address);
  161.         }
  163.         return $this;
  164.     }
  166.     /**
  167.      * Get the sender of this message.
  168.      *
  169.      * @return string
  170.      */
  171.     public function getSender()
  172.     {
  173.         return $this->getHeaderFieldModel('Sender');
  174.     }
  176.     /**
  177.      * Add a From: address to this message.
  178.      *
  179.      * If $name is passed this name will be associated with the address.
  180.      *
  181.      * @param string $address
  182.      * @param string $name    optional
  183.      *
  184.      * @return $this
  185.      */
  186.     public function addFrom($address, $name = null)
  187.     {
  188.         $current = $this->getFrom();
  189.         $current[$address] = $name;
  191.         return $this->setFrom($current);
  192.     }
  194.     /**
  195.      * Set the from address of this message.
  196.      *
  197.      * You may pass an array of addresses if this message is from multiple people.
  198.      *
  199.      * If $name is passed and the first parameter is a string, this name will be
  200.      * associated with the address.
  201.      *
  202.      * @param string|array $addresses
  203.      * @param string       $name      optional
  204.      *
  205.      * @return $this
  206.      */
  207.     public function setFrom($addresses, $name = null)
  208.     {
  209.         if (!is_array($addresses) && isset($name)) {
  210.             $addresses = [$addresses => $name];
  211.         }
  213.         if (!$this->setHeaderFieldModel('From', (array) $addresses)) {
  214.             $this->getHeaders()->addMailboxHeader('From', (array) $addresses);
  215.         }
  217.         return $this;
  218.     }
  220.     /**
  221.      * Get the from address of this message.
  222.      *
  223.      * @return mixed
  224.      */
  225.     public function getFrom()
  226.     {
  227.         return $this->getHeaderFieldModel('From');
  228.     }
  230.     /**
  231.      * Add a Reply-To: address to this message.
  232.      *
  233.      * If $name is passed this name will be associated with the address.
  234.      *
  235.      * @param string $address
  236.      * @param string $name    optional
  237.      *
  238.      * @return $this
  239.      */
  240.     public function addReplyTo($address, $name = null)
  241.     {
  242.         $current = $this->getReplyTo();
  243.         $current[$address] = $name;
  245.         return $this->setReplyTo($current);
  246.     }
  248.     /**
  249.      * Set the reply-to address of this message.
  250.      *
  251.      * You may pass an array of addresses if replies will go to multiple people.
  252.      *
  253.      * If $name is passed and the first parameter is a string, this name will be
  254.      * associated with the address.
  255.      *
  256.      * @param mixed  $addresses
  257.      * @param string $name      optional
  258.      *
  259.      * @return $this
  260.      */
  261.     public function setReplyTo($addresses, $name = null)
  262.     {
  263.         if (!is_array($addresses) && isset($name)) {
  264.             $addresses = [$addresses => $name];
  265.         }
  267.         if (!$this->setHeaderFieldModel('Reply-To', (array) $addresses)) {
  268.             $this->getHeaders()->addMailboxHeader('Reply-To', (array) $addresses);
  269.         }
  271.         return $this;
  272.     }
  274.     /**
  275.      * Get the reply-to address of this message.
  276.      *
  277.      * @return string
  278.      */
  279.     public function getReplyTo()
  280.     {
  281.         return $this->getHeaderFieldModel('Reply-To');
  282.     }
  284.     /**
  285.      * Add a To: address to this message.
  286.      *
  287.      * If $name is passed this name will be associated with the address.
  288.      *
  289.      * @param string $address
  290.      * @param string $name    optional
  291.      *
  292.      * @return $this
  293.      */
  294.     public function addTo($address, $name = null)
  295.     {
  296.         $current = $this->getTo();
  297.         $current[$address] = $name;
  299.         return $this->setTo($current);
  300.     }
  302.     /**
  303.      * Set the to addresses of this message.
  304.      *
  305.      * If multiple recipients will receive the message an array should be used.
  306.      * Example: array('receiver@domain.org', 'other@domain.org' => 'A name')
  307.      *
  308.      * If $name is passed and the first parameter is a string, this name will be
  309.      * associated with the address.
  310.      *
  311.      * @param mixed  $addresses
  312.      * @param string $name      optional
  313.      *
  314.      * @return $this
  315.      */
  316.     public function setTo($addresses, $name = null)
  317.     {
  318.         if (!is_array($addresses) && isset($name)) {
  319.             $addresses = [$addresses => $name];
  320.         }
  322.         if (!$this->setHeaderFieldModel('To', (array) $addresses)) {
  323.             $this->getHeaders()->addMailboxHeader('To', (array) $addresses);
  324.         }
  326.         return $this;
  327.     }
  329.     /**
  330.      * Get the To addresses of this message.
  331.      *
  332.      * @return array
  333.      */
  334.     public function getTo()
  335.     {
  336.         return $this->getHeaderFieldModel('To');
  337.     }
  339.     /**
  340.      * Add a Cc: address to this message.
  341.      *
  342.      * If $name is passed this name will be associated with the address.
  343.      *
  344.      * @param string $address
  345.      * @param string $name    optional
  346.      *
  347.      * @return $this
  348.      */
  349.     public function addCc($address, $name = null)
  350.     {
  351.         $current = $this->getCc();
  352.         $current[$address] = $name;
  354.         return $this->setCc($current);
  355.     }
  357.     /**
  358.      * Set the Cc addresses of this message.
  359.      *
  360.      * If $name is passed and the first parameter is a string, this name will be
  361.      * associated with the address.
  362.      *
  363.      * @param mixed  $addresses
  364.      * @param string $name      optional
  365.      *
  366.      * @return $this
  367.      */
  368.     public function setCc($addresses, $name = null)
  369.     {
  370.         if (!is_array($addresses) && isset($name)) {
  371.             $addresses = [$addresses => $name];
  372.         }
  374.         if (!$this->setHeaderFieldModel('Cc', (array) $addresses)) {
  375.             $this->getHeaders()->addMailboxHeader('Cc', (array) $addresses);
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * Get the Cc address of this message.
  383.      *
  384.      * @return array
  385.      */
  386.     public function getCc()
  387.     {
  388.         return $this->getHeaderFieldModel('Cc');
  389.     }
  391.     /**
  392.      * Add a Bcc: address to this message.
  393.      *
  394.      * If $name is passed this name will be associated with the address.
  395.      *
  396.      * @param string $address
  397.      * @param string $name    optional
  398.      *
  399.      * @return $this
  400.      */
  401.     public function addBcc($address, $name = null)
  402.     {
  403.         $current = $this->getBcc();
  404.         $current[$address] = $name;
  406.         return $this->setBcc($current);
  407.     }
  409.     /**
  410.      * Set the Bcc addresses of this message.
  411.      *
  412.      * If $name is passed and the first parameter is a string, this name will be
  413.      * associated with the address.
  414.      *
  415.      * @param mixed  $addresses
  416.      * @param string $name      optional
  417.      *
  418.      * @return $this
  419.      */
  420.     public function setBcc($addresses, $name = null)
  421.     {
  422.         if (!is_array($addresses) && isset($name)) {
  423.             $addresses = [$addresses => $name];
  424.         }
  426.         if (!$this->setHeaderFieldModel('Bcc', (array) $addresses)) {
  427.             $this->getHeaders()->addMailboxHeader('Bcc', (array) $addresses);
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * Get the Bcc addresses of this message.
  435.      *
  436.      * @return array
  437.      */
  438.     public function getBcc()
  439.     {
  440.         return $this->getHeaderFieldModel('Bcc');
  441.     }
  443.     /**
  444.      * Set the priority of this message.
  445.      *
  446.      * The value is an integer where 1 is the highest priority and 5 is the lowest.
  447.      *
  448.      * @param int $priority
  449.      *
  450.      * @return $this
  451.      */
  452.     public function setPriority($priority)
  453.     {
  454.         $priorityMap = [
  455.             self::PRIORITY_HIGHEST => 'Highest',
  456.             self::PRIORITY_HIGH => 'High',
  457.             self::PRIORITY_NORMAL => 'Normal',
  458.             self::PRIORITY_LOW => 'Low',
  459.             self::PRIORITY_LOWEST => 'Lowest',
  460.             ];
  461.         $pMapKeys = array_keys($priorityMap);
  462.         if ($priority > max($pMapKeys)) {
  463.             $priority = max($pMapKeys);
  464.         } elseif ($priority < min($pMapKeys)) {
  465.             $priority = min($pMapKeys);
  466.         }
  467.         if (!$this->setHeaderFieldModel('X-Priority',
  468.             sprintf('%d (%s)', $priority, $priorityMap[$priority]))) {
  469.             $this->getHeaders()->addTextHeader('X-Priority',
  470.                 sprintf('%d (%s)', $priority, $priorityMap[$priority]));
  471.         }
  473.         return $this;
  474.     }
  476.     /**
  477.      * Get the priority of this message.
  478.      *
  479.      * The returned value is an integer where 1 is the highest priority and 5
  480.      * is the lowest.
  481.      *
  482.      * @return int
  483.      */
  484.     public function getPriority()
  485.     {
  486.         list($priority) = sscanf($this->getHeaderFieldModel('X-Priority'),
  487.             '%[1-5]'
  488.             );
  490.         return $priority ?? 3;
  491.     }
  493.     /**
  494.      * Ask for a delivery receipt from the recipient to be sent to $addresses.
  495.      *
  496.      * @param array $addresses
  497.      *
  498.      * @return $this
  499.      */
  500.     public function setReadReceiptTo($addresses)
  501.     {
  502.         if (!$this->setHeaderFieldModel('Disposition-Notification-To', $addresses)) {
  503.             $this->getHeaders()
  504.                 ->addMailboxHeader('Disposition-Notification-To', $addresses);
  505.         }
  507.         return $this;
  508.     }
  510.     /**
  511.      * Get the addresses to which a read-receipt will be sent.
  512.      *
  513.      * @return string
  514.      */
  515.     public function getReadReceiptTo()
  516.     {
  517.         return $this->getHeaderFieldModel('Disposition-Notification-To');
  518.     }
  520.     /**
  521.      * Attach a {@link Swift_Mime_SimpleMimeEntity} such as an Attachment or MimePart.
  522.      *
  523.      * @return $this
  524.      */
  525.     public function attach(Swift_Mime_SimpleMimeEntity $entity)
  526.     {
  527.         $this->setChildren(array_merge($this->getChildren(), [$entity]));
  529.         return $this;
  530.     }
  532.     /**
  533.      * Remove an already attached entity.
  534.      *
  535.      * @return $this
  536.      */
  537.     public function detach(Swift_Mime_SimpleMimeEntity $entity)
  538.     {
  539.         $newChildren = [];
  540.         foreach ($this->getChildren() as $child) {
  541.             if ($entity !== $child) {
  542.                 $newChildren[] = $child;
  543.             }
  544.         }
  545.         $this->setChildren($newChildren);
  547.         return $this;
  548.     }
  550.     /**
  551.      * Attach a {@link Swift_Mime_SimpleMimeEntity} and return it's CID source.
  552.      *
  553.      * This method should be used when embedding images or other data in a message.
  554.      *
  555.      * @return string
  556.      */
  557.     public function embed(Swift_Mime_SimpleMimeEntity $entity)
  558.     {
  559.         $this->attach($entity);
  561.         return 'cid:'.$entity->getId();
  562.     }
  564.     /**
  565.      * Get this message as a complete string.
  566.      *
  567.      * @return string
  568.      */
  569.     public function toString()
  570.     {
  571.         if (count($children = $this->getChildren()) > 0 && '' != $this->getBody()) {
  572.             $this->setChildren(array_merge([$this->becomeMimePart()], $children));
  573.             $string = parent::toString();
  574.             $this->setChildren($children);
  575.         } else {
  576.             $string = parent::toString();
  577.         }
  579.         return $string;
  580.     }
  582.     /**
  583.      * Returns a string representation of this object.
  584.      *
  585.      * @see toString()
  586.      *
  587.      * @return string
  588.      */
  589.     public function __toString()
  590.     {
  591.         return $this->toString();
  592.     }
  594.     /**
  595.      * Write this message to a {@link Swift_InputByteStream}.
  596.      */
  597.     public function toByteStream(Swift_InputByteStream $is)
  598.     {
  599.         if (count($children = $this->getChildren()) > 0 && '' != $this->getBody()) {
  600.             $this->setChildren(array_merge([$this->becomeMimePart()], $children));
  601.             parent::toByteStream($is);
  602.             $this->setChildren($children);
  603.         } else {
  604.             parent::toByteStream($is);
  605.         }
  606.     }
  608.     /** @see Swift_Mime_SimpleMimeEntity::getIdField() */
  609.     protected function getIdField()
  610.     {
  611.         return 'Message-ID';
  612.     }
  614.     /** Turn the body of this message into a child of itself if needed */
  615.     protected function becomeMimePart()
  616.     {
  617.         $part = new parent($this->getHeaders()->newInstance(), $this->getEncoder(),
  618.             $this->getCache(), $this->getIdGenerator(), $this->userCharset
  619.             );
  620.         $part->setContentType($this->userContentType);
  621.         $part->setBody($this->getBody());
  622.         $part->setFormat($this->userFormat);
  623.         $part->setDelSp($this->userDelSp);
  624.         $part->setNestingLevel($this->getTopNestingLevel());
  626.         return $part;
  627.     }
  629.     /** Get the highest nesting level nested inside this message */
  630.     private function getTopNestingLevel()
  631.     {
  632.         $highestLevel = $this->getNestingLevel();
  633.         foreach ($this->getChildren() as $child) {
  634.             $childLevel = $child->getNestingLevel();
  635.             if ($highestLevel < $childLevel) {
  636.                 $highestLevel = $childLevel;
  637.             }
  638.         }
  640.         return $highestLevel;
  641.     }
  642. }