Bone\Mvc\Controller

Complexity

Total Complexity

25

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	10

Test Coverage

Coverage

96.15%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getMailService()	0	8	2
A	initMailService()	0	11	4
A	init()	0	4	1
A	postDispatch()	0	4	1
A	indexAction()	0	4	1
A	errorAction()	0	7	1
A	notFoundAction()	0	6	1
A	getLog()	0	12	3
A	initLogs()	0	9	2
A	getTranslator()	0	8	2
B	initTranslator()	0	23	6

<?php

namespace Bone\Mvc;

use Bone\Mvc\View\Extension\Plates\Translate;
use Bone\Service\LoggerFactory;
use Bone\Service\MailService;
use Bone\Service\TranslatorFactory;
use InvalidArgumentException;
use League\Plates\Engine;
use LogicException;
use Monolog\Logger;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response\TextResponse;
use Zend\Mail\Transport\Smtp;
use Zend\Mail\Transport\SmtpOptions;

class Controller extends AbstractController
{
    /** @var MailService $mailService */
    private $mailService;

    /** @var Logger[] $log */
    protected $log;

    protected $translator;

    /**
     * Controller constructor.
     * @param ServerRequestInterface $request
     * @throws \Exception
     */
    public function __construct(ServerRequestInterface $request)
    {
        parent::__construct($request);
        $this->initTranslator();
        $this->initLogs();
    }

    /**
     * @return MailService
     */
    public function getMailService()
    {
        if (!$this->mailService instanceof MailService) {
            $this->initMailService();
        }

        return $this->mailService;
    }

    private function initMailService()
    {
        $this->mailService = new MailService();
        $options = Registry::ahoy()->get('mail');
        if (isset($options['name']) && isset($options['host']) && isset($options['port']) ) {
            $transport = new Smtp();
            $options   = new SmtpOptions($options);
            $transport->setOptions($options);
            $this->mailService->setTransport($transport);
        }
    }

    /**
     *  runs before th' controller action
     */
    public function init()
    {
        // extend this t' initialise th' controller
    }

    /**
     *  runs after yer work is done
     */
    public function postDispatch()
    {
        // extend this t' run code after yer controller is finished
    }

    /**
     * @return array
     */
    public function indexAction()
    {
        return ['message' => 'Override this method'];
    }

    public function errorAction()
    {
        $this->disableView();
        $this->disableLayout();
        $this->setBody('500 Page Error.');
        return new TextResponse($this->getBody(), 500);
    }

    public function notFoundAction()
    {
        $this->disableView();
        $this->disableLayout();
        $this->setBody('404 Page Not Found.');
    }

    /**
     * @param string $channel
     * @return Logger
     */
    public function getLog($channel = 'default'): Logger
    {
        if (!$this->log) {

The expression $this->log of type Monolog\Logger[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw new LogicException('No log config found');
        }

        if (!isset($this->log[$channel])) {
            throw new InvalidArgumentException('No log channel with that name found');
        }

        return $this->log[$channel];
    }

    /**
     * @throws \Exception
     */
    private function initLogs()
    {
        $config = Registry::ahoy()->get('log');
        if (is_array($config)) {
            $factory = new LoggerFactory();
            $logs = $factory->createLoggers($config);
            $this->log = $logs;
        }
    }

    /**
     * @return \Zend\I18n\Translator\Translator
     */
    public function getTranslator()
    {
        if (!$this->translator) {
            throw new LogicException('No i18n config found');
        }

        return $this->translator;
    }

    private function initTranslator()
    {
        $config = Registry::ahoy()->get('i18n');
        if (is_array($config) && !$this->translator) {

            $factory = new TranslatorFactory();
            $translator = $factory->createTranslator($config);

            $engine = $this->getViewEngine();
            if ($engine instanceof Engine) {
                $engine->loadExtension(new Translate($translator));
            }

            $defaultLocale = $config['default_locale'] ?: 'en_GB';
            $locale = $this->getParam('locale', $defaultLocale);
            if (!in_array($locale, $config['supported_locales'])) {
                $locale = $defaultLocale;
            }
            $translator->setLocale($locale);

            $this->translator = $translator;
        }
    }
}