Faulancer\Controller\AbstractController

Complexity

Total Complexity

21

Size/Duplication

Total Lines	193
Duplicated Lines	4.15 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getServiceLocator()	0	4	1
A	getSessionManager()	0	4	1
A	getView()	0	13	2
A	getDb()	0	4	1
A	render()	0	4	1
A	requiredPermissions()	0	11	3
A	getRequiredPermissions()	0	4	1
A	redirect()	0	6	1
A	setFlashMessage()	0	5	1
A	getFlashMessage()	0	5	1
B	route()	8	29	6
A	getRequest()	0	4	1

<?php
/**
 * Class AbstractController
 *
 * @package Faulancer\AbstractController
 * @author Florian Knapp <office@florianknapp.de>
 */
namespace Faulancer\Controller;

use Faulancer\Cache\Cache;
use Faulancer\Cache\CacheableInterface;
use Faulancer\Exception\RouteInvalidException;
use Faulancer\Http\Request;
use Faulancer\Http\Response;
use Faulancer\Service\AuthenticatorService;
use Faulancer\Service\Config;
use Faulancer\Service\DbService;
use Faulancer\Service\HttpService;
use Faulancer\Service\SessionManagerService;
use Faulancer\ServiceLocator\ServiceInterface;
use Faulancer\Session\SessionManager;
use Faulancer\View\ViewController;
use Faulancer\ServiceLocator\ServiceLocator;

/**
 * Class AbstractController
 */
abstract class AbstractController
{

    /**
     * Holds the views per controller request
     * @var array
     */
    private $viewArray = [];

    /**
     * @var Request
     */
    protected $request;

    /**
     * @var array
     */
    protected $requiredPermissions = [];

    /**
     * AbstractController constructor.
     * @param Request $request
     */
    public function __construct(Request $request)
    {
        $this->request = $request;
    }

    /**
     * Returns the service locator
     *
     * @return ServiceLocator
     */
    public function getServiceLocator() :ServiceLocator
    {
        return ServiceLocator::instance();
    }

    /**
     * Returns the session manager
     *
     * @return SessionManagerService|ServiceInterface
     */
    public function getSessionManager() :SessionManagerService
    {
        return $this->getServiceLocator()->get(SessionManagerService::class);
    }

    /**
     * Returns the view controller
     *
     * @return ViewController
     */
    public function getView() :ViewController
    {
        $calledClass = get_called_class();

        if (in_array($calledClass, array_keys($this->viewArray))) {
            return $this->viewArray[$calledClass];
        }

        $viewController = new ViewController();
        $this->viewArray[$calledClass] = $viewController;

        return $viewController;
    }

    /**
     * Returns the orm/entity manager
     *
     * @return DbService|ServiceInterface
     */
    public function getDb() :DbService
    {
        return $this->getServiceLocator()->get(DbService::class);
    }

    /**
     * Render view with given template
     *
     * @param  string $template
     * @param  array $variables
     * @return Response
     */
    public function render(string $template = '', $variables = []) :Response
    {
        return new Response($this->getView()->setTemplate($template)->setVariables($variables)->render());
    }

    /**
     * Set required authentication
     *
     * @param array $roles
     * @return bool
     */
    public function requiredPermissions($roles = [])
    {
        /** @var AuthenticatorService $authenticator */
        $authenticator = $this->getServiceLocator()->get(AuthenticatorService::class);

        if (!empty($roles) && $authenticator->isAuthenticated($roles) === false) {
            return $authenticator->redirectToAuthentication();
        }

        return true;
    }

    /**
     * @return array
     */
    public function getRequiredPermissions()
    {
        return $this->requiredPermissions;
    }

    /**
     * @param string $uri
     * @return bool
     */
    public function redirect(string $uri) :bool
    {
        /** @var HttpService $httpService */
        $httpService = $this->getServiceLocator()->get(HttpService::class);
        return $httpService->redirect($uri);
    }

    /**
     * @param string $key
     * @param string $message
     */
    public function setFlashMessage(string $key, string $message)
    {
        $sessionManager = $this->getSessionManager();
        $sessionManager->setFlashMessage($key, $message);
    }

    /**
     * @param $key
     * @return string|null
     */
    public function getFlashMessage(string $key)
    {
        $sessionManager = $this->getSessionManager();
        return $sessionManager->getFlashMessage($key);
    }

    /**
     * @param string $name
     * @param array  $parameters
     * @param bool   $absolute
     *
     * @return string
     * @throws RouteInvalidException
     */
    public function route(string $name, array $parameters = [], $absolute = false)
    {
        /** @var Config $config */
        $config = $this->getServiceLocator()->get(Config::class);
        $routes = $config->get('routes');

        foreach ($routes as $routeName => $routeConfig) {

This code seems to be duplicated across your project.

            if ($routeName === $name) {
                $path = preg_replace('|/\((.*)\)|', '', $routeConfig['path']);
                break;
            }

        }

        if (empty($path)) {
            throw new RouteInvalidException('No route for name "' . $name . '" found');
        }

        if (!empty($parameters)) {
            $path = $path . '/' . implode('/', $parameters);
        }

        if ($absolute) {
            $path = $this->getRequest()->getScheme() . $this->getRequest()->getHost() . $path;
        }

        return $path;
    }

    /**
     * @return Request
     */
    public function getRequest() :Request
    {
        return $this->request;
    }

}