BeyondCode\Mailbox\Routing\Mailbox

Complexity

Total Complexity

21

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	from()	0	4	1
A	to()	0	4	1
A	cc()	0	4	1
A	bcc()	0	4	1
A	subject()	0	4	1
A	fallback()	0	4	1
A	addRoute()	0	8	1
A	createRoute()	0	5	1
A	callMailboxes()	0	19	6
A	shouldStoreInboundEmails()	0	4	1
A	shouldStoreAllInboundEmails()	0	4	2
A	storeEmail()	0	4	1
A	__call()	0	6	1

<?php

namespace BeyondCode\Mailbox\Routing;

use BeyondCode\Mailbox\InboundEmail;
use BeyondCode\Mailbox\MailboxManager;
use Illuminate\Container\Container;
use Illuminate\Support\Collection;
use Illuminate\Support\Traits\ForwardsCalls;

class Mailbox
{
    use ForwardsCalls;

    /** @var RouteCollection */
    protected $routes;

    /** @var Route */
    protected $fallbackRoute;

    /** @var Container */
    protected $container;

    public function __construct(Container $container = null)
    {
        $this->container = $container ?: new Container;

        $this->routes = new RouteCollection;
    }

    public function from(string $pattern, $action): Route
    {
        return $this->addRoute(Route::FROM, $pattern, $action);
    }

    public function to(string $pattern, $action): Route
    {
        return $this->addRoute(Route::TO, $pattern, $action);
    }

    public function cc(string $pattern, $action): Route
    {
        return $this->addRoute(Route::CC, $pattern, $action);
    }

    public function bcc(string $pattern, $action): Route
    {
        return $this->addRoute(Route::BCC, $pattern, $action);
    }

    public function subject(string $pattern, $action): Route
    {
        return $this->addRoute(Route::SUBJECT, $pattern, $action);
    }

    public function fallback($action)
    {
        $this->fallbackRoute = $this->createRoute(Route::FALLBACK, '', $action);
    }

    protected function addRoute(string $matchBy, string $pattern, $action): Route
    {
        $route = $this->createRoute($matchBy, $pattern, $action);

        $this->routes->add($route);

        return $route;
    }

    protected function createRoute(string $subject, string $pattern, $action): Route
    {
        return (new Route($subject, $pattern, $action))
            ->setContainer($this->container);
    }

    public function callMailboxes(InboundEmail $email)
    {
        if (! $email->isValid()) {
            return;
        }

        $matchedRoutes = $this->routes->match($email)->map(function (Route $route) use ($email) {
            $route->run($email);
        });

        if ($matchedRoutes->isEmpty() && $this->fallbackRoute) {
            $matchedRoutes[] = $this->fallbackRoute;
            $this->fallbackRoute->run($email);
        }

        if ($this->shouldStoreInboundEmails() && $this->shouldStoreAllInboundEmails($matchedRoutes)) {
            $this->storeEmail($email);
        }
    }

    protected function shouldStoreInboundEmails(): bool
    {
        return config('mailbox.store_incoming_emails_for_days') > 0;
    }

    protected function shouldStoreAllInboundEmails(Collection $matchedRoutes): bool
    {
        return $matchedRoutes->isNotEmpty() ? true : ! config('mailbox.only_store_matching_emails');
    }

    protected function storeEmail(InboundEmail $email)
    {
        $email->save();
    }

    public function __call($method, $parameters)
    {
        return $this->forwardCallTo(
            $this->container->make(MailboxManager::class), $method, $parameters
        );
    }
}