Email.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Email\Address;
use Elgg\Email\Attachment;
use Elgg\Exceptions\InvalidArgumentException;
use Laminas\Mime\Part;
 
final class Email {
 
    protected $from;
 
    protected $to = [];
 
    protected $cc = [];
 
    protected $bcc = [];
 
    protected $sender;
 
    protected $subject;
 
    protected $body;
 
    protected $params = [];
 
    protected $headers = [];
    
    protected $attachments = [];
 
    public static function factory(array $options = []) {
        $from = elgg_extract('from', $options);
        $to = elgg_extract('to', $options);
        $cc = elgg_extract('cc', $options);
        $bcc = elgg_extract('bcc', $options);
        $subject = elgg_extract('subject', $options);
        $body = elgg_extract('body', $options);
        $params = elgg_extract('params', $options, []);
        $headers = elgg_extract('headers', $options, []);
 
        $email = new self();
        $email->setSender($from);
        $email->setFrom(self::prepareFrom($from));
        $email->setTo($to);
        $email->setCc($cc);
        $email->setBcc($bcc);
        $email->setSubject($subject);
        $email->setBody($body);
        $email->setParams($params);
        $email->setHeaders($headers);
        
        if (isset($params['attachments']) && is_array($params['attachments'])) {
            foreach ($params['attachments'] as $attachment) {
                $email->addAttachment($attachment);
            }
        }
        
        return $email;
    }
 
    public function setSender($sender) {
        $this->sender = $sender;
        return $this;
    }
 
    public function getSender() {
        return $this->sender;
    }
 
    public function setFrom(Address $from) {
        $this->from = $from;
        return $this;
    }
 
    public function getFrom() {
        return $this->from;
    }
 
    public function setTo($recipient): self {
        $this->to = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getTo(): array {
        return $this->to;
    }
 
    public function setCc($recipient): self {
        $this->cc = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getCc(): array {
        return $this->cc;
    }
    
    public function setBcc($recipient): self {
        $this->bcc = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getBcc(): array {
        return $this->bcc;
    }
 
    public function setSubject($subject = '') {
        $this->subject = $subject;
        return $this;
    }
 
    public function getSubject() {
        return elgg_substr($this->subject, 0, (int) _elgg_services()->config->email_subject_limit);
    }
 
    public function setBody($body = '') {
        $this->body = $body;
        return $this;
    }
 
    public function getBody() {
        return $this->body;
    }
 
    public function setParams(array $params = []) {
        $this->params = $params;
        return $this;
    }
 
    public function getParams() {
        return $this->params;
    }
 
    public function addHeader($name, $value) {
        $this->headers[$name] = $value;
        return $this;
    }
 
    public function setHeaders(array $headers = []) {
        $this->headers = $headers;
        return $this;
    }
 
    public function getHeaders() {
        return $this->headers;
    }
    
    public function addAttachment($attachment) {
        
        if ($attachment instanceof Part) {
            $this->attachments[] = $attachment;
            return $this;
        }
        
        if ($attachment instanceof \ElggFile) {
            $this->attachments[] = Attachment::fromElggFile($attachment);
            return $this;
        }
        
        $attachment = Attachment::factory($attachment);
        if (!empty($attachment)) {
            $this->attachments[] = $attachment;
        }
        
        return $this;
    }
    
    public function getAttachments() {
        return $this->attachments;
    }
    
    public function createEntityMessageID(\ElggEntity $entity, bool $add_microtime = false): string {
        $microtime = '';
        if ($add_microtime) {
            $microtime = '.' . microtime(true);
        }
        
        $hostname = parse_url(elgg_get_site_url(), PHP_URL_HOST);
        $urlPath = parse_url(elgg_get_site_url(), PHP_URL_PATH);
        
        return "{$urlPath}.entity.{$entity->guid}{$microtime}@{$hostname}";
    }
 
    protected static function prepareFrom($from) {
        if (empty($from)) {
            // get the site email address
            $site = elgg_get_site_entity();
            $from = new Address($site->getEmailAddress(), $site->getDisplayName());
        } elseif ($from instanceof \ElggSite) {
            // use site email address
            $from = new Address($from->getEmailAddress(), $from->getDisplayName());
        } elseif ($from instanceof \ElggEntity) {
            // If there's an email address, use it - but only if it's not from a user.
            if (!$from instanceof \ElggUser && $from->email) {
                $from = Address::fromEntity($from);
            } else {
                // get the site email address
                $site = elgg_get_site_entity();
                $from_display = elgg_echo('notification:method:email:from', [$from->getDisplayName(), $site->getDisplayName()]);
                $from = new Address($site->getEmailAddress(), $from_display);
            }
        } elseif (is_string($from)) {
            $from = Address::fromString($from);
        }
        
        if (!$from instanceof Address) {
            throw new InvalidArgumentException('From address is not in a valid format');
        }
 
        return $from;
    }
 
    protected function prepareRecipients($recipients) {
        if (empty($recipients)) {
            return [];
        }
        
        if (!is_array($recipients)) {
            $recipients = [$recipients];
        }
        
        $result = [];
        foreach ($recipients as $recipient) {
            if ($recipient instanceof Address) {
                $result[] = $recipient;
                continue;
            }
            
            if ($recipient instanceof \ElggEntity) {
                $recipient = Address::fromEntity($recipient);
            } elseif (is_string($recipient)) {
                $recipient = Address::fromString($recipient);
            }
    
            if (!$recipient instanceof Address) {
                throw new InvalidArgumentException('Recipient address is not in a valid format');
            }
            
            $result[] = $recipient;
        }
        
        return $result;
    }
}