Kodus\Mail\SMTP\SMTPMailService

Complexity

Total Complexity

11

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

92.86%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	send()	0	12	1
A	disconnect()	0	7	1
A	getClient()	0	10	2
A	getSender()	0	12	2
A	getRecipients()	0	18	4

<?php

namespace Kodus\Mail\SMTP;

use Kodus\Mail\MailService;
use Kodus\Mail\Message;
use Kodus\Mail\MIMEWriter;

/**
 * This Mail Service implementation delivers Messages directly to an SMTP server.
 *
 * It will block the script while connecting and delivering the Message.
 */
class SMTPMailService implements MailService
{
    /**
     * @var SMTPAuthenticator
     */
    protected $authenticator;

    /**
     * @var string
     */
    protected $client_domain;

    /**
     * @var SMTPConnector
     */
    private $connector;

    /**
     * @var SMTPClient|null
     */
    private $client;

    /**
     * @param SMTPConnector     $connector     provides the SMTP connection
     * @param SMTPAuthenticator $authenticator performs SMTP authentication
     * @param string            $client_domain client domain-name (provided in handshakes when connecting)
     */
    public function __construct(SMTPConnector $connector, SMTPAuthenticator $authenticator, $client_domain)
    {
        $this->connector = $connector;
        $this->authenticator = $authenticator;
        $this->client_domain = $client_domain;
    }

    public function send(Message $message)
    {
        $this->getClient()->sendMail(
            $this->getSender($message),
            $this->getRecipients($message),
            function ($socket) use ($message) {
                $writer = new MIMEWriter($socket);

                $writer->writeMessage($message);
            }
        );
    }

    /**
     * Internally disconnect the SMTP Client.
     *
     * Long-running services may wish to disconnect the SMTP client after sending a batch
     * of Messages, to avoid timeouts.
     *
     * @return void
     */
    public function disconnect()
    {
        // NOTE: this will cause the SMTP Client instance will fall out of scope, which
        //       will trigger it's destructor, which will send QUIT and close the socket.

        $this->client = null;
    }

    /**
     * Connect and authenticate SMTP Client (if not already connected)
     *
     * @return SMTPClient
     */
    protected function getClient()
    {
        if (! isset($this->client)) {
            $this->client = $this->connector->connect($this->client_domain);

            $this->authenticator->authenticate($this->client);
        }

        return $this->client;
    }

    /**
     * Determine the sender e-mail address from the "Sender" or first "From" field of the Message
     *
     * @param Message $message
     *
     * @return string sender e-mail address
     */
    private function getSender(Message $message)
    {
        $sender = $message->getSender();

        if ($sender) {
            return $sender->getEmail();
        }

        $from = $message->getFrom();

        return $from[0]->getEmail();
    }

    /**
     * Extract recipient e-mail addresses from the "To", "CC" and "BCC" fields of the Message
     *
     * @param Message $message
     *
     * @return string[] list of recipient e-mail addresses
     */
    private function getRecipients(Message $message)
    {
        $recipients = [];

        foreach ($message->getTo() as $recipient) {

The expression $message->getTo() of type object<Kodus\Mail\Address>|array<integer,object<Kodus\Mail\Address>> is not guaranteed to be traversable. How about adding an additional type check?

            $recipients[] = $recipient->getEmail();
        }

        foreach ($message->getCC() as $recipient) {

The expression $message->getCC() of type object<Kodus\Mail\Address>|array<integer,object<Kodus\Mail\Address>> is not guaranteed to be traversable. How about adding an additional type check?

            $recipients[] = $recipient->getEmail();
        }

        foreach ($message->getBCC() as $recipient) {

The expression $message->getBCC() of type object<Kodus\Mail\Address>|array<integer,object<Kodus\Mail\Address>> is not guaranteed to be traversable. How about adding an additional type check?

            $recipients[] = $recipient->getEmail();
        }

        return $recipients;
    }
}