class.ilMimeMail.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

use ILIAS\Refinery\Factory as Refinery;

class ilMimeMail
{
    final public const MAIL_SUBJECT_PREFIX = '[ILIAS]';

    protected static ?ilMailMimeTransport $defaultTransport = null;

    protected ilMailMimeSender $sender;
    protected ilMailMimeSubjectBuilder $subjectBuilder;
    protected ilSetting $settings;
    protected string $subject = '';
    protected string $body = '';
    protected string $finalBody = '';
    protected string $finalBodyAlt = '';
    protected array $sendto = [];
    protected array $acc = [];
    protected array $abcc = [];
    protected array $images = [];
    protected array $aattach = [];
    protected array $actype = [];
    protected array $adispo = [];
    protected array $adisplay = [];
    private readonly Refinery $refinery;

    public function __construct()
    {
        global $DIC;
        $this->settings = $DIC->settings();

        if (!(self::getDefaultTransport() instanceof ilMailMimeTransport)) {
            $factory = $DIC->mail()->mime()->transportFactory();
            self::setDefaultTransport($factory->getTransport());
        }

        $this->subjectBuilder = new ilMailMimeSubjectBuilder($this->settings, self::MAIL_SUBJECT_PREFIX);
        $this->refinery = $DIC->refinery();
    }

    public static function setDefaultTransport(?ilMailMimeTransport $transport): void
    {
        self::$defaultTransport = $transport;
    }

    public static function getDefaultTransport(): ?ilMailMimeTransport
    {
        return self::$defaultTransport;
    }

    public function Subject(string $subject, bool $addPrefix = false, string $contextPrefix = ''): void
    {
        $this->subject = $this->subjectBuilder->subject($subject, $addPrefix, $contextPrefix);
    }

    public function getSubject(): string
    {
        return $this->subject;
    }

    public function From(ilMailMimeSender $sender): void
    {
        $this->sender = $sender;
    }

    public function To($to): void
    {
        if (is_array($to)) {
            $this->sendto = $to;
        } else {
            $this->sendto[] = $to;
        }
    }

    public function Cc($cc): void
    {
        if (is_array($cc)) {
            $this->acc = $cc;
        } else {
            $this->acc[] = $cc;
        }
    }

    public function Bcc($bcc): void
    {
        if (is_array($bcc)) {
            $this->abcc = $bcc;
        } else {
            $this->abcc[] = $bcc;
        }
    }

    public function getTo(): array
    {
        return $this->sendto;
    }

    public function getCc(): array
    {
        return $this->acc;
    }

    public function getBcc(): array
    {
        return $this->abcc;
    }

    public function Body(string $body): void
    {
        $this->body = $body;
    }

    public function getFinalBody(): string
    {
        return $this->finalBody;
    }

    public function getFinalBodyAlt(): string
    {
        return $this->finalBodyAlt;
    }

    public function getFrom(): ilMailMimeSender
    {
        return $this->sender;
    }

    public function Attach(
        string $filename,
        string $file_type = '',
        string $disposition = 'inline',
        ?string $display_name = null
    ): void {
        if ($file_type === '') {
            $file_type = 'application/octet-stream';
        }

        $this->aattach[] = $filename;
        $this->actype[] = $file_type;
        $this->adispo[] = $disposition;
        $this->adisplay[] = $display_name;
    }

    public function getAttachments(): array
    {
        $attachments = [];

        $i = 0;
        foreach ($this->aattach as $attachment) {
            $name = '';
            if (isset($this->adisplay[$i]) && is_string($this->adisplay[$i]) && $this->adisplay[$i] !== '') {
                $name = $this->adisplay[$i];
            }

            $attachments[] = [
                'path' => $attachment,
                'name' => $name
            ];
            ++$i;
        }

        return $attachments;
    }

    public function getImages(): array
    {
        return array_values($this->images);
    }

    protected function build(): void
    {
        global $DIC;

        $this->finalBodyAlt = '';
        $this->finalBody = '';
        $this->images = [];

        if ($DIC->settings()->get('mail_send_html', '0')) {
            $skin = $DIC['ilClientIniFile']->readVariable('layout', 'skin');
            $style = $DIC['ilClientIniFile']->readVariable('layout', 'style');

            $this->buildBodyMultiParts($skin, $style);
            $this->buildHtmlInlineImages($skin, $style);
        } else {
            $this->finalBody = $this->removeHTMLTags($this->body);
        }
    }

    private function removeHTMLTags(string $maybeHTML): string
    {
        $maybeHTML = str_ireplace(['<br />', '<br>', '<br/>'], "\n", $maybeHTML);

        return strip_tags($maybeHTML);
    }

    protected function buildBodyMultiParts(string $skin, string $style): void
    {
        if ($this->body === '') {
            $this->body = ' ';
        }

        if (strip_tags($this->body, '<b><u><i><a>') === $this->body) {
            // Let's assume(!) that there is no HTML
            // (except certain tags, e.g. used for object title formatting, where the consumer is not aware of this),
            // so convert "\n" to "<br>"
            $this->finalBodyAlt = strip_tags($this->body);
            $this->body = $this->refinery->string()->makeClickable()->transform(nl2br($this->body));
        } else {
            // if there is HTML, convert "<br>" to "\n" and strip tags for plain text alternative
            $this->finalBodyAlt = strip_tags(str_ireplace(["<br />", "<br>", "<br/>"], "\n", $this->body));
        }

        $this->finalBody = str_replace('{PLACEHOLDER}', $this->body, $this->getHtmlEnvelope($skin, $style));
    }

    private function getPathToRootDirectory(): string
    {
        return realpath(dirname(__DIR__, 4) . '/');
    }

    protected function getHtmlEnvelope(string $skin, string $style): string
    {
        $bracket_path = $this->getPathToRootDirectory() . '/components/ILIAS/Mail/templates/default/tpl.html_mail_template.html';
        if ($skin !== 'default') {
            $locations = [
                $skin,
                $skin . '/' . $style
            ];

            foreach ($locations as $location) {
                $custom_path = $this->getPathToRootDirectory(
                ) . '/public/Customizing/skin/' . $location . '/components/ILIAS/Mail/tpl.html_mail_template.html';
                if (is_file($custom_path)) {
                    $bracket_path = $custom_path;
                    break;
                }
            }
        }

        return file_get_contents($bracket_path);
    }

    protected function buildHtmlInlineImages(string $skin, string $style): void
    {
        $this->gatherImagesFromDirectory(
            $this->getPathToRootDirectory() . '/components/ILIAS/Mail/templates/default/img'
        );

        if ($skin !== 'default') {
            $locations = [
                $skin,
                $skin . '/' . $style
            ];

            foreach ($locations as $location) {
                $custom_directory = $this->getPathToRootDirectory(
                ) . '/public/Customizing/skin/' . $location . '/components/ILIAS/Mail/img';
                if (is_dir($custom_directory) && is_readable($custom_directory)) {
                    $this->gatherImagesFromDirectory($custom_directory, true);
                    break;
                }
            }
        }
    }

    protected function gatherImagesFromDirectory(string $directory, bool $clearPrevious = false): void
    {
        if ($clearPrevious) {
            $this->images = [];
        }

        foreach (new RegexIterator(
            new DirectoryIterator($directory),
            '/\.(jpg|jpeg|gif|svg|png)$/i'
        ) as $file) {
            $cid = 'img/' . $file->getFilename();

            $this->images[$cid] = [
                'path' => $file->getPathname(),
                'cid' => $cid,
                'name' => $file->getFilename()
            ];
        }
    }

    public function Send(?ilMailMimeTransport $transport = null): bool
    {
        if (!($transport instanceof ilMailMimeTransport)) {
            $transport = self::getDefaultTransport();
        }

        $this->build();

        return $transport->send($this);
    }
}