Email.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Email\Attachment;
use Elgg\Exceptions\InvalidArgumentException;
use Psr\Log\LogLevel;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Part\DataPart;
 
final class Email {
 
    protected ?Address $from = null;
 
    protected array $to = [];
 
    protected array $cc = [];
 
    protected array $bcc = [];
 
    protected ?Address $sender = null;
 
    protected string $subject = '';
 
    protected ?string $body = null;
 
    protected array $params = [];
 
    protected array $headers = [];
    
    protected array $attachments = [];
 
    public static function factory(array $options = []): Email {
        $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(mixed $sender): self {
        $prepared_sender = $this->prepareRecipients($sender);
        $this->sender = !empty($prepared_sender) ? $prepared_sender[0] : null;
        return $this;
    }
 
    public function getSender(): Address {
        if (isset($this->sender)) {
            return $this->sender;
        }
        
        $site = elgg_get_site_entity();
        return new Address($site->getEmailAddress(), $site->getDisplayName());
    }
 
    public function setFrom(Address $from): self {
        $this->from = $from;
        return $this;
    }
 
    public function getFrom(): ?Address {
        return $this->from;
    }
 
    public function setTo(mixed $recipient): self {
        $this->to = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getTo(): array {
        return $this->to;
    }
 
    public function setCc(mixed $recipient): self {
        $this->cc = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getCc(): array {
        return $this->cc;
    }
    
    public function setBcc(mixed $recipient): self {
        $this->bcc = $this->prepareRecipients($recipient);
        return $this;
    }
 
    public function getBcc(): array {
        return $this->bcc;
    }
 
    public function setSubject(string $subject = ''): self {
        $this->subject = $subject;
        return $this;
    }
 
    public function getSubject(): string {
        return elgg_substr($this->subject, 0, (int) _elgg_services()->config->email_subject_limit);
    }
 
    public function setBody(string $body = ''): self {
        $this->body = $body;
        return $this;
    }
 
    public function getBody(): ?string {
        return $this->body;
    }
 
    public function setParams(array $params = []): self {
        $this->params = $params;
        return $this;
    }
 
    public function getParams(): array {
        return $this->params;
    }
 
    public function addHeader(string $name, mixed $value): self {
        $this->headers[$name] = $value;
        return $this;
    }
 
    public function setHeaders(array $headers = []): self {
        $this->headers = $headers;
        return $this;
    }
 
    public function getHeaders(): array {
        return $this->headers;
    }
    
    public function addAttachment(mixed $attachment): self {
        if ($attachment instanceof DataPart) {
            $this->attachments[] = $attachment;
            return $this;
        }
        
        try {
            $this->attachments[] = Attachment::factory($attachment);
        } catch (InvalidArgumentException $e) {
            elgg_log($e->getMessage(), LogLevel::ERROR);
        }
        
        return $this;
    }
    
    public function getAttachments(): array {
        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(mixed $from): Address {
        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 && !empty($from->email)) {
                $from = new Address($from->email, $from->getDisplayName());
            } 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::create($from);
        }
        
        if (!$from instanceof Address) {
            throw new InvalidArgumentException('From address is not in a valid format');
        }
        
        return $from;
    }
 
    protected function prepareRecipients(mixed $recipients): array {
        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 \ElggSite) {
                $recipient = new Address($recipient->getEmailAddress(), $recipient->getDisplayName());
            } elseif ($recipient instanceof \ElggEntity && !empty($recipient->email)) {
                $recipient = new Address($recipient->email, $recipient->getDisplayName());
            } elseif (is_string($recipient)) {
                $recipient = Address::create($recipient);
            }
    
            if (!$recipient instanceof Address) {
                throw new InvalidArgumentException('Recipient address is not in a valid format');
            }
            
            $result[] = $recipient;
        }
        
        return $result;
    }
}