Resohead\LaravelTestMail\TestMailCommand

Complexity

Total Complexity

23

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	handle()	0	28	3
A	setArgumentDefaults()	0	8	1
A	getPresetValue()	0	7	1
A	getConfigPath()	0	4	1
A	getConfigKeys()	0	6	1
A	setPreset()	0	4	1
A	setRecipient()	0	5	1
A	setDriver()	0	5	1
A	setConnection()	0	5	1
A	setStack()	0	4	2
A	isOnQueue()	0	4	2
A	hasQueueOptions()	0	4	3
A	hasQueuePresets()	0	4	3
A	rules()	0	8	1

<?php

namespace Resohead\LaravelTestMail;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Mail;
use Illuminate\Contracts\Mail\Mailable;
use Illuminate\Support\Facades\Validator;
use Resohead\LaravelTestMail\TestMailable;
use Resohead\LaravelTestMail\SendTestEmailJob;
use \Illuminate\Contracts\Config\Repository as Config;

class TestMailCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'mail:test {recipient?} {--preset=} {--queue} {--driver=} {--connection=} {--stack=}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Send a test email';

    protected $validator;
    protected $config;

    protected $preset;
    protected $recipient;
    protected $driver;
    protected $stack;
    protected $connection;

    /**
     * Create a new command instance.
     *
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(Validator $validator, Config $config)
    {
        parent::__construct();
        $this->validator = $validator;
        $this->config = $config;
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $this->setArgumentDefaults();

        $validation = $this->validator::make([
                'email' => $this->recipient,
                'driver' => $this->driver,
                'preset' => $this->preset
            ], $this->rules()
        );

        if ($validation->fails()) {
            collect($validation->errors()->all())->each(function($error){
                $this->error($error);
            });
            return 1;
        }
        
        $this->config->set('mail.driver', $this->driver);

        $mailable = new TestMailable($this->recipient);

        $this->isOnQueue()
            ? Mail::queue($mailable->onConnection($this->connection)->onQueue($this->stack)) 
            : Mail::send($mailable);
            
        $this->comment("A test email ($this->driver) has been sent to $this->recipient");
    }

    protected function setArgumentDefaults()
    {
        $this->setPreset();
        $this->setRecipient();
        $this->setDriver();
        $this->setConnection();
        $this->setStack();
    }

    protected function getPresetValue($key, $default = null)
    {
        return $this->config->get(
                implode('.', [$this->getConfigPath(), $this->preset, $key]), 
                $default
            );
    }

    protected function getConfigPath()
    {
        return 'mail-test.presets';
    }

    protected function getConfigKeys()
    {
        return array_keys(
            $this->config->get($this->getConfigPath())
        );
    }

    protected function setPreset()
    {
        $this->preset = $this->option('preset');
    }

    protected function setRecipient()
    {
        $this->recipient = $this->argument('recipient') ??
             $this->getPresetValue('recipient', $this->config->get('mail.from.address'));
    }

    protected function setDriver()
    {
        $this->driver = $this->option('driver') ?? 
            $this->getPresetValue('driver', $this->config->get('mail.driver'));
    }

    protected function setConnection()
    {
        $this->connection = $this->option('connection') ?? 
            $this->getPresetValue('connection', $this->config->get('queue.default'));
    }

    protected function setStack()
    {
        $this->stack = $this->option('stack') ?: $this->getPresetValue('stack', 'default');
    }

    protected function isOnQueue(): bool
    {
        return $this->hasQueueOptions() || $this->hasQueuePresets();
    }

    protected function hasQueueOptions()
    {
        return $this->option('queue') || $this->option('stack') || $this->option('connection');
    }

    protected function hasQueuePresets()
    {
        return $this->getPresetValue('queue') || $this->getPresetValue('connection') || $this->getPresetValue('stack');
    }

    protected function rules(): array
    {
        return [
            'email' => 'email',
            'driver' => 'required',
            'preset' => 'nullable|sometimes|in:'.implode(',', $this->getConfigKeys()),
        ];
    }
}