Faulancer\Controller\AbstractController::__call()

Complexity

Conditions	3
Paths	3

Size

Total Lines	33
Code Lines	14

Duplication

Lines	16
Ratio	48.48 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	AbstractController::route()	0	4	1
A	AbstractController::getRequest()	0	4	1
A	AbstractController::addAssets()	0	3	1

<?php

namespace Faulancer\Controller;

use Faulancer\Exception\ConfigInvalidException;
use Faulancer\Exception\FileNotFoundException;
use Faulancer\Exception\InvalidArgumentException;
use Faulancer\Exception\PluginException;
use Faulancer\Exception\ServiceNotFoundException;
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\ResponseService;
use Faulancer\Service\SessionManagerService;
use Faulancer\ServiceLocator\ServiceInterface;
use Faulancer\View\Helper\Route;
use Faulancer\View\ViewController;
use Faulancer\ServiceLocator\ServiceLocator;

/**
 * Class AbstractController
 *
 * @category Controller
 * @package  Faulancer\AbstractController
 * @author   Florian Knapp <office@florianknapp.de>
 */
abstract class AbstractController
{

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

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

    /**
     * AbstractController constructor.
     *
     * @param Request $request The request object
     */
    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
     *
     * @throws ServiceNotFoundException
     */
    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), true)) {
            return $this->_viewArray[$calledClass];
        }

        $viewController = new ViewController();

        $this->_viewArray[$calledClass] = $viewController;

        return $viewController;

    }

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

    /**
     * Render view with given template
     *
     * @param string $template  The template to be rendered
     * @param array  $variables The variables for the template
     *
     * @return Response
     *
     * @throws ServiceNotFoundException
     */
    public function render(string $template = '', $variables = []) :Response
    {
        $this->addAssets();

        /** @var Response $response */
        $response = $this->getServiceLocator()->get(ResponseService::class);

        try {

            $viewResult = $this->getView()
                ->setTemplate($template)
                ->setVariables($variables)
                ->render();

        } catch (FileNotFoundException $e) {
            $viewResult = $e->getMessage();
        } catch (ConfigInvalidException $e) {
            $viewResult = $e->getMessage();
        }

        return $response->setContent($viewResult);
    }

    /**
     * Check if user is permitted based on his role(s)
     *
     * @param array $roles The corresponding user roles
     *
     * @return bool|null
     *
     * @throws ServiceNotFoundException
     */
    public function isPermitted($roles = [])
    {
        /** @var AuthenticatorService $authService */
        $authService = $this->getServiceLocator()->get(AuthenticatorService::class);

        return $authService->isPermitted($roles);
    }

    /**
     * Redirect to specific uri
     *
     * @param string $uri The target uri
     *
     * @return bool
     *
     * @throws ServiceNotFoundException
     * @throws InvalidArgumentException
     */
    public function redirect(string $uri) :bool
    {
        /** @var HttpService $httpService */
        $httpService = $this->getServiceLocator()->get(HttpService::class);
        return $httpService->redirect($uri);
    }

    /**
     * Set a generic text token which is valid for exactly one call
     *
     * @param string $key     Key for the flash message
     * @param string $message Content for the flash message
     *
     * @return void
     *
     * @throws ServiceNotFoundException
     */
    public function setFlashMessage(string $key, string $message)
    {
        $sessionManager = $this->getSessionManager();
        $sessionManager->setFlashMessage($key, $message);
    }

    /**
     * Retrieve a flash message
     *
     * @param string $key The flash message key
     *
     * @return string|null
     *
     * @throws ServiceNotFoundException
     */
    public function getFlashMessage(string $key)
    {
        $sessionManager = $this->getSessionManager();
        return $sessionManager->getFlashMessage($key);
    }

    /**
     * Get the url for a specific route name
     *
     * @param string $name       Name of the route
     * @param array  $parameters Apply parameters where necessary
     * @param bool   $absolute   Return an absolute url with host as prefix
     *
     * @return string
     */
    public function route(string $name, array $parameters = [], $absolute = false)
    {
        return (new Route())($this->getView(), $name, $parameters, $absolute);
    }

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

    /**
     * Add default assets for every action
     */
    protected function addAssets() {
        // Should be inherited by child classes
    }

}