ElfSundae\Multimail\Mailer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

77.78%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getSwiftMailerManager()	0	4	1
A	setSwiftMailerManager()	0	6	1
A	getSwiftMailerForMessage()	0	10	2
B	send()	0	30	3
A	sendSwiftMessage()	0	16	3
A	forceReconnection()	0	8	2
A	getSwiftMailer()	0	4	1
A	setSwiftMailer()	0	7	1
A	registerSendingMessageHandler()	0	6	1
A	callSendingMessageHandler()	0	10	3

<?php

namespace ElfSundae\Multimail;

use Closure;
use Illuminate\Contracts\Mail\Mailable as MailableContract;
use Illuminate\Mail\Events\MessageSending;
use Illuminate\Mail\Mailer as BaseMailer;
use Swift_Mailer;

class Mailer extends BaseMailer
{
    /**
     * The Swift Mailer Manager instance.
     *
     * @var \ElfSundae\Multimail\SwiftMailerManager
     */
    protected $swiftManager;

    /**
     * The registered handler of sending message.
     *
     * @var \Closure|string
     */
    protected $sendingMessageHandler;

    /**
     * Get the Swift Mailer Manager instance.
     *
     * @return \ElfSundae\Multimail\SwiftMailerManager
     */
    public function getSwiftMailerManager()
    {
        return $this->swiftManager;
    }

    /**
     * Set the Swift Mailer Manager instance.
     *
     * @param  \ElfSundae\Multimail\SwiftMailerManager  $manager
     * @return $this
     */
    public function setSwiftMailerManager(SwiftMailerManager $manager)
    {
        $this->swiftManager = $manager;

        return $this;
    }

    /**
     * Register handler of sending message.
     *
     * @param  \Closure|string  $handler
     * @return $this
     */
    public function registerSendingMessageHandler($handler)
    {
        $this->sendingMessageHandler = $handler;

        return $this;
    }

    /**
     * Call the registered handler of sending message.
     *
     * @param  mixed  ...$args
     * @return mixed
     */
    protected function callSendingMessageHandler(...$args)
    {
        if ($this->sendingMessageHandler instanceof Closure) {
            return $this->container->call($this->sendingMessageHandler, $args);
        }

        if (is_string($this->sendingMessageHandler)) {
            return $this->container->call($this->sendingMessageHandler, $args, 'sendingMessage');
        }
    }

    /**
     * Get a Swift Mailer instance for the given message.
     *
     * @param  mixed  $message
     * @return \Swift_Mailer
     */
    protected function getSwiftMailerForMessage($message)
    {
        $swift = $this->callSendingMessageHandler($message, $this);

        if ($swift instanceof Swift_Mailer) {
            return $swift;
        }

        return $this->swiftManager->mailer($swift);
    }

    /**
     * Send a new message using a view.
     *
     * @param  string|array  $view
     * @param  array  $data
     * @param  \Closure|string  $callback
     */
    public function send($view, array $data = [], $callback = null)
    {
        if ($view instanceof MailableContract) {
            return $view->send($this);
        }

        // First we need to parse the view, which could either be a string or an array
        // containing both an HTML and plain text versions of the view which should
        // be used when sending an e-mail. We will extract both of them out here.
        list($view, $plain, $raw) = $this->parseView($view);

        $data['message'] = $message = $this->createMessage();

        // Once we have retrieved the view content for the e-mail we will set the body
        // of this message using the HTML type, which will provide a simple wrapper
        // to creating view based emails that are able to receive arrays of data.
        $this->addContent($message, $view, $plain, $raw, $data);

        $this->callMessageBuilder($callback, $message);

        if (isset($this->to['address'])) {
            $message->to($this->to['address'], $this->to['name'], true);
        }

        $swift = $this->getSwiftMailerForMessage($message);

        $message = $message->getSwiftMessage();

        $this->sendSwiftMessage($message, $swift);
    }

    /**
     * Send a Swift Message instance.
     *
     * @param  \Swift_Message  $message
     * @param  \Swift_Mailer  $swift
     */
    protected function sendSwiftMessage($message, $swift = null)
    {
        if ($this->events) {
            $this->events->fire(new MessageSending($message));
        }

        if (is_null($swift)) {
            $swift = $this->getSwiftMailer();
        }

        try {
            return $swift->send($message, $this->failedRecipients);
        } finally {
            $this->forceReconnection($swift);
        }
    }

    /**
     * Force the transport to re-connect.
     *
     * This will prevent errors in daemon queue situations.
     *
     * @param  \Swift_Mailer  $swift
     */
    protected function forceReconnection($swift = null)
    {
        if (is_null($swift)) {
            $swift = $this->getSwiftMailer();
        }

        $swift->getTransport()->stop();
    }

    /**
     * Get the Swift Mailer instance.
     *
     * @return \Swift_Mailer
     */
    public function getSwiftMailer()
    {
        return $this->swiftManager->mailer();
    }

    /**
     * Set the Swift Mailer instance.
     *
     * @param  string|\Swift_Mailer  $swift
     */
    public function setSwiftMailer($swift)
    {
        $this->swiftManager->setDefaultMailer($swift);

        // Our $swift is managed by the SwiftMailerManager singleton,
        // so just let $this->swift go.
    }
}