Phauthentic\Authorization\AuthorizationService

Complexity

Total Complexity

15

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Test Coverage

Coverage

94.59%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	authorizationChecked()	0	3	1
A	__construct()	0	3	1
A	skipAuthorization()	0	5	1
A	applyScope()	0	7	1
A	can()	0	24	6
A	getScopeHandler()	0	9	2
A	getCanHandler()	0	9	3

<?php
declare(strict_types = 1);
/**
 * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 * @link          https://cakephp.org CakePHP(tm) Project
 * @since         1.0.0
 * @license       https://opensource.org/licenses/mit-license.php MIT License
 */
namespace Phauthentic\Authorization;

use Phauthentic\Authorization\Policy\BeforePolicyInterface;
use Phauthentic\Authorization\Policy\Exception\MissingMethodException;
use Phauthentic\Authorization\Policy\ResolverInterface;
use Phauthentic\Authorization\Policy\ResultInterface;

The type Phauthentic\Authorization\Policy\ResultInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use RuntimeException;

/**
 * Authorization Service
 */
class AuthorizationService implements AuthorizationServiceInterface
{
    /**
     * Authorization policy resolver.
     *
     * @var \Phauthentic\Authorization\Policy\ResolverInterface
     */
    protected $resolver;

    /**
     * Track whether or not authorization was checked.
     *
     * @var bool
     */
    protected $authorizationChecked = false;

    /**
     * Constructor
     *
     * @param \Phauthentic\Authorization\Policy\ResolverInterface $resolver Authorization policy resolver.
     */
    public function __construct(ResolverInterface $resolver)
    {
        $this->resolver = $resolver;
    }

    /**
     * {@inheritDoc}
     */
    public function can(?IdentityInterface $user, string $action, $resource)
    {
        $this->authorizationChecked = true;
        $policy = $this->resolver->getPolicy($resource);

        if ($policy instanceof BeforePolicyInterface) {
            $result = $policy->before($user, $resource, $action);

            if ($result instanceof ResultInterface || is_bool($result)) {
                return $result;

The expression return $result also could return the type Phauthentic\Authorization\Policy\ResultInterface which is incompatible with the return type mandated by Phauthentic\Authorization\AuthorizationServiceInterface::can() of boolean.

            }
            if ($result !== null) {

The condition $result !== null is always false.

                throw new RuntimeException('Pre-authorization check must return `bool` or `null`.');
            }
        }

        $handler = $this->getCanHandler($policy, $action);
        $result = $handler($user, $resource);

        if ($result instanceof ResultInterface) {
            return $result;

The expression return $result returns the type Phauthentic\Authorization\Policy\ResultInterface which is incompatible with the return type mandated by Phauthentic\Authorization\AuthorizationServiceInterface::can() of boolean.

        }

        return $result === true;
    }

    /**
     * {@inheritDoc}
     */
    public function applyScope(?IdentityInterface $user, string $action, $resource)
    {
        $this->authorizationChecked = true;
        $policy = $this->resolver->getPolicy($resource);
        $handler = $this->getScopeHandler($policy, $action);

        return $handler($user, $resource);
    }

    /**
     * Returns a policy action handler.
     *
     * @param mixed $policy Policy object.
     * @param string $action Action name.
     * @return callable
     * @throws \Phauthentic\Authorization\Policy\Exception\MissingMethodException
     */
    protected function getCanHandler($policy, $action)
    {
        $method = 'can' . ucfirst($action);

        if (!method_exists($policy, $method) && !method_exists($policy, '__call')) {
            throw (new MissingMethodException())->setMessageVars([$method, $action, get_class($policy)]);
        }

        return [$policy, $method];
    }

    /**
     * Returns a policy scope action handler.
     *
     * @param mixed $policy Policy object.
     * @param string $action Action name.
     * @return callable
     * @throws \Phauthentic\Authorization\Policy\Exception\MissingMethodException
     */
    protected function getScopeHandler($policy, $action): callable
    {
        $method = 'scope' . ucfirst($action);

        if (!method_exists($policy, $method)) {
            throw (new MissingMethodException())->setMessageVars([$method, $action, get_class($policy)]);
        }

        return [$policy, $method];
    }

    /**
     * {@inheritDoc}
     */
    public function authorizationChecked(): bool
    {
        return $this->authorizationChecked;
    }

    /**
     * {@inheritDoc}
     */
    public function skipAuthorization(): AuthorizationServiceInterface
    {
        $this->authorizationChecked = true;

        return $this;
    }
}