[ Index ]

MailPress 7.2

[ Index ]     [ Classes ]     [ Functions ]     [ Variables ]     [ Constants ]     [ Statistics ]    

title

Body

[close]

/mp-includes/composer/vendor/swiftmailer/swiftmailer/lib/classes/Swift/Mime/ -> SimpleMessage.php (source)

   1  <?php
   2  
   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   */
  10  
  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;
  23  
  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      }
  56  
  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      }
  66  
  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          }
  79  
  80          return $this;
  81      }
  82  
  83      /**
  84       * Get the subject of this message.
  85       *
  86       * @return string
  87       */
  88      public function getSubject()
  89      {
  90          return $this->getHeaderFieldModel('Subject');
  91      }
  92  
  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          }
 103  
 104          return $this;
 105      }
 106  
 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      }
 116  
 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          }
 129  
 130          return $this;
 131      }
 132  
 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      }
 142  
 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          }
 158  
 159          if (!$this->setHeaderFieldModel('Sender', (array) $address)) {
 160              $this->getHeaders()->addMailboxHeader('Sender', (array) $address);
 161          }
 162  
 163          return $this;
 164      }
 165  
 166      /**
 167       * Get the sender of this message.
 168       *
 169       * @return string
 170       */
 171      public function getSender()
 172      {
 173          return $this->getHeaderFieldModel('Sender');
 174      }
 175  
 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;
 190  
 191          return $this->setFrom($current);
 192      }
 193  
 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          }
 212  
 213          if (!$this->setHeaderFieldModel('From', (array) $addresses)) {
 214              $this->getHeaders()->addMailboxHeader('From', (array) $addresses);
 215          }
 216  
 217          return $this;
 218      }
 219  
 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      }
 229  
 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;
 244  
 245          return $this->setReplyTo($current);
 246      }
 247  
 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          }
 266  
 267          if (!$this->setHeaderFieldModel('Reply-To', (array) $addresses)) {
 268              $this->getHeaders()->addMailboxHeader('Reply-To', (array) $addresses);
 269          }
 270  
 271          return $this;
 272      }
 273  
 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      }
 283  
 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;
 298  
 299          return $this->setTo($current);
 300      }
 301  
 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          }
 321  
 322          if (!$this->setHeaderFieldModel('To', (array) $addresses)) {
 323              $this->getHeaders()->addMailboxHeader('To', (array) $addresses);
 324          }
 325  
 326          return $this;
 327      }
 328  
 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      }
 338  
 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;
 353  
 354          return $this->setCc($current);
 355      }
 356  
 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          }
 373  
 374          if (!$this->setHeaderFieldModel('Cc', (array) $addresses)) {
 375              $this->getHeaders()->addMailboxHeader('Cc', (array) $addresses);
 376          }
 377  
 378          return $this;
 379      }
 380  
 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      }
 390  
 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;
 405  
 406          return $this->setBcc($current);
 407      }
 408  
 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          }
 425  
 426          if (!$this->setHeaderFieldModel('Bcc', (array) $addresses)) {
 427              $this->getHeaders()->addMailboxHeader('Bcc', (array) $addresses);
 428          }
 429  
 430          return $this;
 431      }
 432  
 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      }
 442  
 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          }
 472  
 473          return $this;
 474      }
 475  
 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              );
 489  
 490          return $priority ?? 3;
 491      }
 492  
 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          }
 506  
 507          return $this;
 508      }
 509  
 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      }
 519  
 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]));
 528  
 529          return $this;
 530      }
 531  
 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);
 546  
 547          return $this;
 548      }
 549  
 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);
 560  
 561          return 'cid:'.$entity->getId();
 562      }
 563  
 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          }
 578  
 579          return $string;
 580      }
 581  
 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      }
 593  
 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      }
 607  
 608      /** @see Swift_Mime_SimpleMimeEntity::getIdField() */
 609      protected function getIdField()
 610      {
 611          return 'Message-ID';
 612      }
 613  
 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());
 625  
 626          return $part;
 627      }
 628  
 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          }
 639  
 640          return $highestLevel;
 641      }
 642  }


Generated: Tue May 19 15:55:14 2020 Cross-referenced by PHPXref 0.7.1