snapshot of https://github.com/espocrm/espocrm.git (master, 2026-09-18; blobs > 131072B omitted)

application/Espo/Core/Mail/Sender.php

@@ -0,0 +1,594 @@
+<?php
+/************************************************************************
+ * This file is part of EspoCRM.
+ *
+ * EspoCRM – Open Source CRM application.
+ * Copyright (C) 2014-2026 EspoCRM, Inc.
+ * Website: https://www.espocrm.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * The interactive user interfaces in modified source and object code versions
+ * of this program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU Affero General Public License version 3.
+ *
+ * In accordance with Section 7(b) of the GNU Affero General Public License version 3,
+ * these Appropriate Legal Notices must retain the display of the "EspoCRM" word.
+ ************************************************************************/
+
+namespace Espo\Core\Mail;
+
+use Espo\Core\FileStorage\Manager as FileStorageManager;
+use Espo\Core\Mail\Exceptions\NoSmtp;
+use Espo\Core\Mail\Sender\AttachmentContainer;
+use Espo\Core\Mail\Sender\MessageContainer;
+use Espo\Core\Mail\Sender\TransportPreparatorFactory;
+use Espo\Core\ORM\Repository\Option\SaveOption;
+use Espo\ORM\EntityCollection;
+use Espo\Core\Field\DateTime;
+use Espo\Core\Utils\Config;
+use Espo\Core\Utils\Log;
+use Espo\Core\Mail\Account\SendingAccountProvider;
+use Espo\Core\Mail\Exceptions\SendingError;
+use Espo\Entities\Attachment;
+use Espo\Entities\Email;
+use Espo\ORM\EntityManager;
+
+use Symfony\Component\Mailer\Envelope;
+use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
+use Symfony\Component\Mailer\Transport\TransportInterface;
+use Symfony\Component\Mime\Address;
+use Symfony\Component\Mime\Email as Message;
+use Symfony\Component\Mime\Part\DataPart;
+
+use Exception;
+use LogicException;
+use InvalidArgumentException;
+
+/**
+ * Sends emails. Builds parameters for sending. Should not be used directly.
+ */
+class Sender
+{
+    private ?TransportInterface $transport = null;
+    private bool $isGlobal = false;
+    /** @var array<string, mixed> */
+    private array $params = [];
+    /** @var array<string, mixed> */
+    private array $overrideParams = [];
+    private ?string $envelopeFromAddress = null;
+    /** @var ?iterable<Attachment|AttachmentContainer> */
+    private $attachmentList = null;
+    /** @var array{string, string}[] */
+    private array $headers = [];
+    private ?MessageContainer $messageContainer = null;
+
+    private const ATTACHMENT_ATTR_CONTENTS = 'contents';
+
+    public function __construct(
+        private Config $config,
+        private EntityManager $entityManager,
+        private Log $log,
+        private SendingAccountProvider $accountProvider,
+        private FileStorageManager $fileStorageManager,
+        private ConfigDataProvider $configDataProvider,
+        private TransportPreparatorFactory $transportPreparatorFactory,
+    ) {
+        $this->useGlobal();
+    }
+
+    private function resetParams(): void
+    {
+        $this->params = [];
+        $this->envelopeFromAddress = null;
+        $this->attachmentList = null;
+        $this->overrideParams = [];
+        $this->headers = [];
+        $this->messageContainer = null;
+    }
+
+    /**
+     * With parameters.
+     *
+     * @param SenderParams|array<string, mixed> $params
+     */
+    public function withParams($params): self
+    {
+        if ($params instanceof SenderParams) {
+            $params = $params->toArray();
+        } else if (!is_array($params)) {
+            throw new InvalidArgumentException();
+        }
+
+        $paramList = [
+            'fromAddress',
+            'fromName',
+            'replyToAddress',
+            'replyToName',
+        ];
+
+        foreach (array_keys($params) as $key) {
+            if (!in_array($key, $paramList)) {
+                unset($params[$key]);
+            }
+        }
+
+        $this->overrideParams = array_merge($this->overrideParams, $params);
+
+        return $this;
+    }
+
+    /**
+     * With specific SMTP parameters.
+     *
+     * @param SmtpParams|array<string, mixed> $params
+     */
+    public function withSmtpParams($params): self
+    {
+        if ($params instanceof SmtpParams) {
+            $params = $params->toArray();
+        } else if (!is_array($params)) {
+            throw new InvalidArgumentException();
+        }
+        return $this->useSmtp($params);
+    }
+
+    /**
+     * With specific attachments.
+     *
+     * @param iterable<Attachment|AttachmentContainer> $attachmentList
+     */
+    public function withAttachments(iterable $attachmentList): self
+    {
+        $this->attachmentList = $attachmentList;
+
+        return $this;
+    }
+
+    /**
+     * With an envelope from address.
+     *
+     * @since 9.1.0
+     */
+    public function withEnvelopeFromAddress(string $fromAddress): void
+    {
+        $this->envelopeFromAddress = $fromAddress;
+    }
+
+    /**
+     * @since 9.2.0
+     * @internal
+     */
+    public function withMessageContainer(MessageContainer $messageContainer): self
+    {
+        $this->messageContainer = $messageContainer;
+
+        return $this;
+    }
+
+    /**
+     * Add a header.
+     *
+     * @param string $name A header name.
+     * @param string $value A header value.
+     * @since 9.1.0
+     */
+    public function withAddedHeader(string $name, string $value): self
+    {
+        $this->headers[] = [$name, $value];
+
+        return $this;
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     */
+    private function useSmtp(array $params = []): self
+    {
+        $this->isGlobal = false;
+
+        $this->applySmtp($params);
+
+        return $this;
+    }
+
+    private function useGlobal(): void
+    {
+        $this->params = [];
+        $this->isGlobal = true;
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     */
+    private function applySmtp(array $params = []): void
+    {
+        $this->params = $params;
+
+        $smtpParams = SmtpParams::fromArray($params);
+
+        $preparator = $this->transportPreparatorFactory->create($smtpParams);
+
+        $this->transport = $preparator->prepare($smtpParams);
+    }
+
+    /**
+     * @throws NoSmtp
+     */
+    private function applyGlobal(): void
+    {
+        $systemAccount = $this->accountProvider->getSystem();
+
+        if (!$systemAccount) {
+            throw new NoSmtp("No system SMTP settings.");
+        }
+
+        $smtpParams = $systemAccount->getSmtpParams();
+
+        if (!$smtpParams) {
+            throw new NoSmtp("No system SMTP settings.");
+        }
+
+        $this->applySmtp($smtpParams->toArray());
+    }
+
+    /**
+     * Send an email.
+     *
+     * @throws SendingError
+     */
+    public function send(Email $email): void
+    {
+        if ($this->isGlobal) {
+            $this->applyGlobal();
+        }
+
+        $message = new Message();
+
+        $params = array_merge($this->params, $this->overrideParams);
+
+        $this->applyHeaders($email, $message);
+        $this->applyFrom($email, $message, $params);
+        $this->addRecipientAddresses($email, $message);
+        $this->applyReplyTo($email, $message, $params);
+        $this->applySubject($email, $message);
+        $this->applyBody($email, $message);
+        $this->applyMessageId($email, $message);
+
+        if (!$this->transport) {
+            throw new LogicException();
+        }
+
+        $envelope = $this->prepareEnvelope($message);
+
+        if ($this->messageContainer) {
+            $this->messageContainer->message = new Sender\Message($message);
+        }
+
+        try {
+            $this->transport->send($message, $envelope);
+        } catch (Exception|TransportExceptionInterface $e) {
+            $this->resetParams();
+            $this->useGlobal();
+
+            $this->handleException($e);
+        }
+
+        $email
+            ->setStatus(Email::STATUS_SENT)
+            ->setDateSent(DateTime::createNow())
+            ->setSendAt(null);
+
+        $this->resetParams();
+        $this->useGlobal();
+    }
+
+    /**
+     * @return DataPart[]
+     */
+    private function getAttachmentParts(Email $email): array
+    {
+        /** @var EntityCollection<Attachment> $collection */
+        $collection = $this->entityManager
+            ->getCollectionFactory()
+            ->create(Attachment::ENTITY_TYPE);
+
+        if (!$email->isNew()) {
+            foreach ($email->getAttachments() as $attachment) {
+                $collection[] = $attachment;
+            }
+        }
+
+        /** @var AttachmentContainer[] $containers */
+        $containers = [];
+
+        if ($this->attachmentList !== null) {
+            foreach ($this->attachmentList as $attachment) {
+                if ($attachment instanceof Attachment) {
+                    $collection[] = $attachment;
+                } else {
+                    $containers[] = $attachment;
+                }
+            }
+        }
+
+        $list = [];
+
+        foreach ($collection as $attachment) {
+            $contents = $this->getAttachmentContents($attachment);
+
+            $part = new DataPart(
+                body: $contents,
+                filename: $attachment->getName() ?? '',
+                contentType: $attachment->getType(),
+            );
+
+            $list[] = $part;
+        }
+
+        $this->prepareContainerParts($containers, $list);
+
+        return $list;
+    }
+
+    /**
+     * @return DataPart[]
+     */
+    private function getInlineAttachmentParts(Email $email): array
+    {
+        $list = [];
+
+        foreach ($email->getInlineAttachmentList() as $attachment) {
+            $contents = $this->getAttachmentContents($attachment);
+
+            $part = (new DataPart($contents, null, $attachment->getType()))
+                ->asInline()
+                ->setContentId($attachment->getId() . '@espo');
+
+            $list[] = $part;
+        }
+
+        return $list;
+    }
+
+    /**
+     * @throws SendingError
+     */
+    private function handleException(Exception|TransportExceptionInterface $e): never
+    {
+        if ($e instanceof TransportExceptionInterface) {
+            $message = "unknownError";
+
+            if (
+                stripos($e->getMessage(), 'password') !== false ||
+                stripos($e->getMessage(), 'credentials') !== false ||
+                stripos($e->getMessage(), '5.7.8') !== false ||
+                stripos($e->getMessage(), '5.7.3') !== false
+            ) {
+                $message = 'invalidCredentials';
+            }
+
+            $this->log->error("Email sending error: " . $e->getMessage(), ['exception' => $e]);
+
+            throw new SendingError($message);
+        }
+
+        throw new SendingError($e->getMessage());
+    }
+
+    private function addRecipientAddresses(Email $email, Message $message): void
+    {
+        $value = $email->get('to');
+
+        if ($value) {
+            foreach (explode(';', $value) as $address) {
+                $message->addTo(trim($address));
+            }
+        }
+
+        $value = $email->get('cc');
+
+        if ($value) {
+            foreach (explode(';', $value) as $address) {
+                $message->addCC(trim($address));
+            }
+        }
+
+        $value = $email->get('bcc');
+
+        if ($value) {
+            foreach (explode(';', $value) as $address) {
+                $message->addBCC(trim($address));
+            }
+        }
+
+        $value = $email->get('replyTo');
+
+        if ($value) {
+            foreach (explode(';', $value) as $address) {
+                $message->addReplyTo(trim($address));
+            }
+        }
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     * @throws NoSmtp
+     */
+    private function applyFrom(Email $email, Message $message, array $params): void
+    {
+        $fromName = $params['fromName'] ?? $this->config->get('outboundEmailFromName');
+
+        $fromAddress = $email->get('from');
+
+        if ($fromAddress) {
+            $fromAddress = trim($fromAddress);
+        } else {
+            if (
+                empty($params['fromAddress']) &&
+                !$this->configDataProvider->getSystemOutboundAddress()
+            ) {
+                throw new NoSmtp('outboundEmailFromAddress is not specified in config.');
+            }
+
+            $fromAddress = $params['fromAddress'] ?? $this->configDataProvider->getSystemOutboundAddress();
+
+            $email->setFromAddress($fromAddress);
+        }
+
+        $message->addFrom(new Address($fromAddress, $fromName ?? ''));
+
+        $fromString = '<' . $fromAddress . '>';
+
+        if ($fromName) {
+            $fromString = $fromName . ' ' . $fromString;
+        }
+
+        $email->set('fromString', $fromString);
+
+        $message->sender($fromAddress);
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     */
+    private function applyReplyTo(Email $email, Message $message, array $params): void
+    {
+        $address = $params['replyToAddress'] ?? null;
+        $name = $params['replyToName'] ?? null;
+
+        if (!$address) {
+            return;
+        }
+
+        $message->replyTo(new Address($address, $name ?? ''));
+
+        $email->setReplyToAddressList([$address]);
+    }
+
+    private function applyMessageId(Email $email, Message $message): void
+    {
+        $messageId = $email->getMessageId();
+
+        if (
+            !$messageId ||
+            strlen($messageId) < 4 ||
+            str_starts_with($messageId, 'dummy:')
+        ) {
+            $messageId = EmailSender::generateMessageId($email);
+
+            $email->setMessageId('<' . $messageId . '>');
+
+            if ($email->hasId()) {
+                $this->entityManager->saveEntity($email, [SaveOption::SILENT => true]);
+            }
+        } else {
+            $messageId = substr($messageId, 1, strlen($messageId) - 2);
+        }
+
+        $message->getHeaders()->addIdHeader('Message-ID', $messageId);
+    }
+
+    private function applyBody(Email $email, Message $message): void
+    {
+        $message->text($email->getBodyPlainForSending());
+
+        if ($email->isHtml()) {
+            $message->html($email->getBodyForSending());
+        }
+
+        foreach ($this->getAttachmentParts($email) as $part) {
+            $message->addPart($part);
+        }
+
+        foreach ($this->getInlineAttachmentParts($email) as $part) {
+            $message->addPart($part);
+        }
+    }
+
+    private function applySubject(Email $email, Message $message): void
+    {
+        $message->subject($email->getSubject() ?? '');
+    }
+
+    private function applyHeaders(Email $email, Message $message): void
+    {
+        foreach ($this->headers as $item) {
+            $message->getHeaders()->addTextHeader($item[0], $item[1]);
+        }
+
+        if ($email->isAutoReply() && !$message->getHeaders()->has('Auto-Submitted')) {
+            $message->getHeaders()->addTextHeader('Auto-Submitted', 'auto-replied');
+        }
+    }
+
+    private function prepareEnvelope(Message $message): ?Envelope
+    {
+        if (!$this->envelopeFromAddress) {
+            return null;
+        }
+
+        $recipients = [
+            ...$message->getTo(),
+            ...$message->getCc(),
+            ...$message->getBcc(),
+        ];
+
+        return new Envelope(new Address($this->envelopeFromAddress), $recipients);
+    }
+
+    /**
+     * @todo Use stream.
+     *
+     */
+    private function getAttachmentContents(Attachment $attachment): string
+    {
+        return $attachment->has(self::ATTACHMENT_ATTR_CONTENTS) ?
+            $attachment->get(self::ATTACHMENT_ATTR_CONTENTS) :
+            $this->fileStorageManager->getContents($attachment);
+    }
+
+    /**
+     * @param AttachmentContainer[] $containers
+     * @param DataPart[] $list
+     */
+    private function prepareContainerParts(array $containers, array &$list): void
+    {
+        foreach ($containers as $container) {
+            $attachment = $container->attachment;
+
+            $contents = $this->getAttachmentContents($attachment);
+
+            $part = new DataPart(
+                body: $contents,
+                filename: $attachment->getName() ?? '',
+                contentType: $attachment->getType(),
+            );
+
+            if ($container->inline) {
+                $part->asInline();
+            }
+
+            if ($container->contentTypeParams && $attachment->getType()) {
+                $part->getHeaders()->addParameterizedHeader(
+                    name: 'Content-Type',
+                    value: $attachment->getType(),
+                    params: $container->contentTypeParams,
+                );
+            }
+
+            $list[] = $part;
+        }
+    }
+}