WebHemi\Renderer\Helper\IsAllowedHelper

Complexity

Total Complexity

11

Size/Duplication

Total Lines	143
Duplicated Lines	10.49 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getName()	0	4	1
A	getDefinition()	0	4	1
A	getDescription()	0	4	1
A	getOptions()	0	4	1
A	__construct()	15	15	1
B	__invoke()	0	27	3
A	checkResourceNameAgainstRouting()	0	17	3

<?php
/**
 * WebHemi.
 *
 * PHP version 7.1
 *
 * @copyright 2012 - 2017 Gixx-web (http://www.gixx-web.com)
 * @license   https://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link      http://www.gixx-web.com
 */
declare(strict_types = 1);

namespace WebHemi\Renderer\Helper;

use WebHemi\Acl\ServiceInterface as AclInterface;
use WebHemi\Auth\ServiceInterface as AuthInterface;
use WebHemi\Configuration\ServiceInterface as ConfigurationInterface;
use WebHemi\Data\Entity\AccessManagement\ResourceEntity;
use WebHemi\Data\Entity\ApplicationEntity;
use WebHemi\Data\Entity\User\UserEntity;
use WebHemi\Data\Storage\AccessManagement\ResourceStorage;
use WebHemi\Data\Storage\ApplicationStorage;
use WebHemi\Environment\ServiceInterface as EnvironmentInterface;
use WebHemi\Renderer\HelperInterface;

/**
 * Class IsAllowedHelper
 */
class IsAllowedHelper implements HelperInterface
{
    /** @var ConfigurationInterface */
    private $configuration;
    /** @var EnvironmentInterface */
    private $environmentManager;
    /** @var AclInterface */
    private $aclAdapter;
    /** @var AuthInterface */
    private $authAdapter;
    /** @var ResourceStorage */
    private $resourceStorage;
    /** @var ApplicationStorage */
    private $applicationStorage;

    /**
     * Should return the name of the helper.
     *
     * @return string
     * @codeCoverageIgnore - plain text
     */
    public static function getName() : string
    {
        return 'isAllowed';
    }

    /**
     * Should return the name of the helper.
     *
     * @return string
     * @codeCoverageIgnore - plain text
     */
    public static function getDefinition() : string
    {
        return '{% if isAllowed("routeAlias") %}';
    }

    /**
     * Should return a description text.
     *
     * @return string
     * @codeCoverageIgnore - plain text
     */
    public static function getDescription() : string
    {
        return 'Checks if the given user has access to the given resource in the given application.';
    }

    /**
     * Gets helper options for the render.
     *
     * @return array
     * @codeCoverageIgnore - empty array
     */
    public static function getOptions() : array
    {
        return [];
    }

    /**
     * IsAllowedHelper constructor.
     *
     * @param ConfigurationInterface $configuration
     * @param EnvironmentInterface   $environmentManager
     * @param AclInterface           $aclAdapter
     * @param AuthInterface          $authAdapter
     * @param ResourceStorage        $resourceStorage
     * @param ApplicationStorage     $applicationStorage
     */
    public function __construct(

This method seems to be duplicated in your project.

        ConfigurationInterface $configuration,
        EnvironmentInterface $environmentManager,
        AclInterface $aclAdapter,
        AuthInterface $authAdapter,
        ResourceStorage $resourceStorage,
        ApplicationStorage $applicationStorage
    ) {
        $this->configuration = $configuration;
        $this->environmentManager = $environmentManager;
        $this->aclAdapter = $aclAdapter;
        $this->authAdapter = $authAdapter;
        $this->resourceStorage = $resourceStorage;
        $this->applicationStorage = $applicationStorage;
    }

    /**
     * A renderer helper should be called with its name.
     *
     * @return bool
     */
    public function __invoke() : bool
    {
        /** @var UserEntity $userEntity */
        $userEntity = $this->authAdapter->getIdentity();
        // Without user, access should be denied.
        if (!$userEntity) {
            return false;
        }

        $arguments = func_get_args();

        $applicationName = $arguments[1] ?? $this->environmentManager->getSelectedApplication();
        /** @var null|ApplicationEntity $applicationEntity */
        $applicationEntity = $this->applicationStorage->getApplicationByName($applicationName);

        // For invalid applications the path will be checked against the current (valid) application
        if (!$applicationEntity instanceof ApplicationEntity) {
            $applicationName = $this->environmentManager->getSelectedApplication();
        }

        $resourceName = $arguments[0] ?? '';
        $this->checkResourceNameAgainstRouting($resourceName, $applicationName);
        /** @var null|ResourceEntity $resourceEntity */
        $resourceEntity = $this->resourceStorage->getResourceByName($resourceName);

        return $this->aclAdapter->isAllowed($userEntity, $resourceEntity, $applicationEntity);
    }

    /**
     * Matches the given resource name against router URLs and if found, changes it to the assigned middleware name.
     * @TODO: make sure it is NOT possible to give a custom resource with a name that can match against a router path.
     *
     * @param string $resourceName
     * @param string $applicationName
     */
    private function checkResourceNameAgainstRouting(string&$resourceName, string $applicationName) : void
    {
        $applicationConfig = $this->configuration
            ->getData('applications/'.$applicationName);

        $applicationRouteConfig = $this->configuration
            ->getData('router/'.$applicationConfig['module']);

        $tempName = trim($resourceName, '/');

        foreach ($applicationRouteConfig as $routeAlias => $routeData) {
            if ($routeAlias == $tempName) {
                $resourceName = $routeData['middleware'];
                break;
            }
        }
    }
}