Genkgo\Mail\MessageBodyCollection

Complexity

Total Complexity

72

Size/Duplication

Total Lines	474
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	23

Test Coverage

Coverage

95.19%

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	withHtml()	0	7	1
A	withHtmlAndNoGeneratedAlternativeText()	0	6	1
A	withAlternativeText()	0	6	1
A	withAttachment()	0	19	3
A	withEmbeddedImage()	0	6	1
A	withAttachedMessage()	0	14	1
A	withQuotedMessage()	0	4	1
A	getHtml()	0	4	1
A	getText()	0	4	1
A	getAttachments()	0	4	1
A	getEmbeddedImages()	0	4	1
A	createMessage()	0	4	1
A	attachToMessage()	0	13	3
A	inReplyTo()	0	7	2
A	inReplyToAll()	0	7	2
A	newReply()	0	14	3
A	asForwardTo()	0	6	1
A	createMessageRoot()	0	13	2
A	createMessageHumanReadable()	0	13	2
A	createMessageText()	0	21	5
A	extract()	0	23	5
C	extractFromMimePart()	0	35	12
A	extractSubject()	0	8	2
A	determineReplyHeader()	0	9	3
A	createReferencedMessage()	0	22	3
B	decodeBodyPart()	0	21	6
B	decodeMessageBody()	0	21	6

<?php
declare(strict_types=1);

namespace Genkgo\Mail;

use Genkgo\Mail\Header\Cc;
use Genkgo\Mail\Header\ContentTransferEncoding;
use Genkgo\Mail\Header\ContentType;
use Genkgo\Mail\Header\GenericHeader;
use Genkgo\Mail\Header\HeaderName;
use Genkgo\Mail\Header\ParsedHeader;
use Genkgo\Mail\Header\Subject;
use Genkgo\Mail\Header\To;
use Genkgo\Mail\Mime\Boundary;
use Genkgo\Mail\Mime\EmbeddedImage;
use Genkgo\Mail\Mime\HtmlPart;
use Genkgo\Mail\Mime\MultiPart;
use Genkgo\Mail\Mime\MultiPartInterface;
use Genkgo\Mail\Mime\PartInterface;
use Genkgo\Mail\Mime\PlainTextPart;
use Genkgo\Mail\Mime\ResourceAttachment;
use Genkgo\Mail\Stream\Base64DecodedStream;
use Genkgo\Mail\Stream\QuotedPrintableDecodedStream;

final class MessageBodyCollection
{
    /**
     * @var string
     */
    private $html = '';

    /**
     * @var AlternativeText
     */
    private $text;

    /**
     * @var array|PartInterface[]
     */
    private $attachments = [];

    /**
     * @var array|PartInterface[]
     */
    private $embedImages = [];

    /**
     * @param string $html
     */
    public function __construct(string $html = '')
    {
        $this->html = $html;
        $this->text = AlternativeText::fromHtml($html);
    }

    /**
     * @param string $html
     * @return MessageBodyCollection
     */
    public function withHtml(string $html): self
    {
        $clone = clone $this;
        $clone->html = $html;
        $clone->text = AlternativeText::fromHtml($html);
        return $clone;
    }

    /**
     * @param string $html
     * @return MessageBodyCollection
     */
    public function withHtmlAndNoGeneratedAlternativeText(string $html): self
    {
        $clone = clone $this;
        $clone->html = $html;
        return $clone;
    }

    /**
     * @param AlternativeText $text
     * @return MessageBodyCollection
     */
    public function withAlternativeText(AlternativeText $text): self
    {
        $clone = clone $this;
        $clone->text = $text;
        return $clone;
    }

    /**
     * @param PartInterface $part
     * @return MessageBodyCollection
     */
    public function withAttachment(PartInterface $part): self
    {
        try {
            $disposition = $part->getHeader('Content-Disposition')->getValue()->getRaw();
            if ($disposition !== 'attachment') {
                throw new \InvalidArgumentException(
                    'An attachment must have Content-Disposition header with value `attachment`'
                );
            }
        } catch (\UnexpectedValueException $e) {
            throw new \InvalidArgumentException(
                'An attachment must have an Content-Disposition header'
            );
        }

        $clone = clone $this;
        $clone->attachments[] = $part;
        return $clone;
    }

    /**
     * @param EmbeddedImage $embeddedImage
     * @return MessageBodyCollection
     */
    public function withEmbeddedImage(EmbeddedImage $embeddedImage): self
    {
        $clone = clone $this;
        $clone->embedImages[] = $embeddedImage;
        return $clone;
    }

    /**
     * @param MessageInterface $message
     * @return MessageBodyCollection
     */
    public function withAttachedMessage(MessageInterface $message): self
    {
        return $this
            ->withAttachment(
                ResourceAttachment::fromString(
                    (string)$message,
                    \transliterator_transliterate(
                        'Any-Latin; NFD; [:Nonspacing Mark:] Remove; NFC; [:Punctuation:] Remove;',
                        $this->extractSubject($message)
                    ) . '.eml',
                    new ContentType('message/rfc822')
                )
            );
    }

    /**
     * @param MessageInterface $message
     * @param QuotationInterface $quotation
     * @return MessageBodyCollection
     */
    public function withQuotedMessage(MessageInterface $message, QuotationInterface $quotation): self
    {
        return $quotation->quote($this, $message);
    }

    /**
     * @return string
     */
    public function getHtml(): string
    {
        return $this->html;
    }

    /**
     * @return AlternativeText
     */
    public function getText(): AlternativeText
    {
        return $this->text;
    }

    /**
     * @return array|PartInterface[]
     */
    public function getAttachments(): iterable
    {
        return $this->attachments;
    }

    /**
     * @return array|PartInterface[]
     */
    public function getEmbeddedImages(): iterable
    {
        return $this->embedImages;
    }

    /**
     * @return MessageInterface
     */
    public function createMessage(): MessageInterface
    {
        return (new MimeMessageFactory())->createMessage($this->createMessageRoot());
    }

    /**
     * @param MessageInterface $message
     * @return MessageInterface
     */
    public function attachToMessage(MessageInterface $message): MessageInterface
    {
        $newMessage = $this->createMessage();

        /** @var HeaderInterface[] $headers */
        foreach ($newMessage->getHeaders() as $headers) {
            foreach ($headers as $header) {
                $message = $message->withHeader($header);
            }
        }

        return $message->withBody($newMessage->getBody());
    }

    /**
     * @param MessageInterface $originalMessage
     * @return MessageInterface
     */
    public function inReplyTo(MessageInterface $originalMessage): MessageInterface
    {
        return $this->newReply(
            $originalMessage,
            $originalMessage->hasHeader('Reply-To') ? ['Reply-To'] : ['From']
        );
    }

    /**
     * @param MessageInterface $originalMessage
     * @return MessageInterface
     */
    public function inReplyToAll(MessageInterface $originalMessage): MessageInterface
    {
        return $this->newReply(
            $originalMessage,
            $originalMessage->hasHeader('Reply-To') ? ['Reply-To'] : ['From', 'Cc']
        );
    }

    /**
     * @param MessageInterface $originalMessage
     * @param array<int, string> $replyRecipientHeaderNames
     * @return MessageInterface
     */
    private function newReply(MessageInterface $originalMessage, array $replyRecipientHeaderNames): MessageInterface
    {
        $reply = $this
            ->createReferencedMessage($originalMessage)
            ->withHeader(new Subject('Re: ' . $this->extractSubject($originalMessage)));

        foreach ($replyRecipientHeaderNames as $replyRecipientHeaderName) {
            foreach ($originalMessage->getHeader($replyRecipientHeaderName) as $recipientHeader) {
                $reply = $reply->withHeader($this->determineReplyHeader($recipientHeader));
            }
        }

        return $reply;
    }

    /**
     * @param MessageInterface $originalMessage
     * @return MessageInterface
     */
    public function asForwardTo(MessageInterface $originalMessage): MessageInterface
    {
        return $this
            ->createReferencedMessage($originalMessage)
            ->withHeader(new Subject('Fwd: ' . $this->extractSubject($originalMessage)));
    }

    /**
     * @return PartInterface
     */
    private function createMessageRoot(): PartInterface
    {
        if (!empty($this->attachments)) {
            return (new MultiPart(
                Boundary::newRandom(),
                new ContentType('multipart/mixed')
            ))
                ->withPart($this->createMessageHumanReadable())
                ->withParts($this->attachments);
        }

        return $this->createMessageHumanReadable();
    }

    /**
     * @return PartInterface
     */
    private function createMessageHumanReadable(): PartInterface
    {
        if (!empty($this->embedImages)) {
            return (new MultiPart(
                Boundary::newRandom(),
                new ContentType('multipart/related')
            ))
                ->withPart($this->createMessageText())
                ->withParts($this->embedImages);
        }

        return $this->createMessageText();
    }

    /**
     * @return PartInterface
     */
    private function createMessageText(): PartInterface
    {
        if ($this->text->isEmpty() && $this->html === '') {
            return new PlainTextPart('');
        }

        if ($this->text->isEmpty()) {
            return new HtmlPart($this->html);
        }

        if ($this->html === '') {
            return new PlainTextPart((string)$this->text);
        }

        return (new MultiPart(
            Boundary::newRandom(),
            new ContentType('multipart/alternative')
        ))
            ->withPart(new PlainTextPart((string)$this->text))
            ->withPart(new HtmlPart($this->html));
    }

    /**
     * @param MessageInterface $message
     * @return MessageBodyCollection
     */
    public static function extract(MessageInterface $message): MessageBodyCollection
    {
        $collection = new self();

        try {
            $collection->extractFromMimePart(MultiPart::fromMessage($message));
        } catch (\InvalidArgumentException $e) {
            foreach ($message->getHeader('Content-Type') as $header) {
                $contentType = $header->getValue()->getRaw();
                if ($contentType === 'text/html') {
                    $collection->html = \rtrim((string)self::decodeMessageBody($message));
                }

                if ($contentType === 'text/plain') {
                    $collection->text = new AlternativeText(
                        \rtrim((string)self::decodeMessageBody($message))
                    );
                }
            }
        }

        return $collection;
    }

    /**
     * @param MultiPartInterface $parts
     */
    private function extractFromMimePart(MultiPartInterface $parts): void
    {
        foreach ($parts->getParts() as $part) {
            $contentType = $part->getHeader('Content-Type')->getValue()->getRaw();
            $hasDisposition = $part->hasHeader('Content-Disposition');

            if (!$hasDisposition && $contentType === 'text/html') {
                $this->html = (string)$this->decodeBodyPart($part);
                continue;
            }

            if (!$hasDisposition && $contentType === 'text/plain') {
                $this->text = new AlternativeText((string)$this->decodeBodyPart($part));
                continue;
            }

            if ($hasDisposition) {
                $disposition = $part->getHeader('Content-Disposition')->getValue()->getRaw();

                if ($disposition === 'attachment') {
                    $this->attachments[] = $part;
                    continue;
                }

                if ($disposition === 'inline' && \substr($contentType, 0, 6) === 'image/' && $part->hasHeader('Content-ID')) {
                    $this->embedImages[] = $part;
                    continue;
                }
            }

            if ($part instanceof MultiPartInterface) {
                $this->extractFromMimePart($part);
            }
        }
    }

    /**
     * @param MessageInterface $message
     * @return string
     */
    private function extractSubject(MessageInterface $message): string
    {
        foreach ($message->getHeader('Subject') as $header) {
            return $header->getValue()->getRaw();
        }

        return '';
    }

    /**
     * @param HeaderInterface $header
     * @return HeaderInterface
     */
    private function determineReplyHeader(HeaderInterface $header): HeaderInterface
    {
        $headerName = $header->getName();
        if ($headerName->equals(new HeaderName('Reply-To')) || $headerName->equals(new HeaderName('From'))) {

new \Genkgo\Mail\Header\HeaderName('Reply-To') is of type object<Genkgo\Mail\Header\HeaderName>, but the function expects a object<self>.

new \Genkgo\Mail\Header\HeaderName('From') is of type object<Genkgo\Mail\Header\HeaderName>, but the function expects a object<self>.

            return new To(AddressList::fromString((string)$header->getValue()));
        }

        return new Cc(AddressList::fromString((string)$header->getValue()));
    }

    /**
     * @param MessageInterface $originalMessage
     * @return MessageInterface
     */
    private function createReferencedMessage(MessageInterface $originalMessage): MessageInterface
    {
        $reply = $this->createMessage();

        foreach ($originalMessage->getHeader('Message-ID') as $messageIdHeader) {
            $references = $messageIdHeader->getValue()->getRaw();
            foreach ($originalMessage->getHeader('References') as $referenceHeader) {
                $references = $referenceHeader->getValue()->getRaw() . ', ' . $references;
            }

            return $reply
                ->withHeader(
                    new ParsedHeader(
                        new HeaderName('In-Reply-To'),
                        $messageIdHeader->getValue()
                    )
                )
                ->withHeader(new GenericHeader('References', $references));
        }

        return $reply;
    }

    /**
     * @param PartInterface $part
     * @return StreamInterface
     */
    private static function decodeBodyPart(PartInterface $part): StreamInterface
    {
        if (!$part->hasHeader('Content-Transfer-Encoding')) {
            return $part->getBody();
        }

        $encoding = $part->getHeader('Content-Transfer-Encoding')->getValue();
        switch ($encoding) {
            case 'quoted-printable':
                return QuotedPrintableDecodedStream::fromString((string)$part->getBody());
            case 'base64':
                return Base64DecodedStream::fromString((string)$part->getBody());
            case '7bit':
            case '8bit':
                return $part->getBody();
            default:
                throw new \UnexpectedValueException(
                    'Cannot decode body of mime part, unknown transfer encoding ' . $encoding
                );
        }
    }

    /**
     * @param MessageInterface $message
     * @return StreamInterface
     */
    private static function decodeMessageBody(MessageInterface $message): StreamInterface
    {
        foreach ($message->getHeader('Content-Transfer-Encoding') as $header) {
            $encoding = $header->getValue();
            switch ($encoding) {
                case 'quoted-printable':
                    return QuotedPrintableDecodedStream::fromString((string)$message->getBody());
                case 'base64':
                    return Base64DecodedStream::fromString((string)$message->getBody());
                case '7bit':
                case '8bit':
                    return $message->getBody();
                default:
                    throw new \UnexpectedValueException(
                        'Cannot decode message body, unknown transfer encoding ' . $encoding
                    );
            }
        }

        return $message->getBody();
    }
}