Limoncello\Auth\Authorization\PolicyDecision\PolicyDecisionPoint

Complexity

Total Complexity

10

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	evaluate()	0	17	3
A	getEncodePolicySet()	0	4	1
A	getLogger()	0	4	1
A	initWithPolicySet()	0	4	1
A	initWithData()	0	6	1
A	setEncodePolicySet()	0	4	1

<?php declare(strict_types=1);

namespace Limoncello\Auth\Authorization\PolicyDecision;

/**
 * Copyright 2015-2019 info@neomerx.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Auth\Authorization\PolicyDecision\Algorithms\BasePolicyOrSetAlgorithm;
use Limoncello\Auth\Authorization\PolicyDecision\Algorithms\DefaultTargetSerializeTrait;
use Limoncello\Auth\Authorization\PolicyDecision\Algorithms\Encoder;
use Limoncello\Auth\Contracts\Authorization\PolicyAdministration\PolicySetInterface;
use Limoncello\Auth\Contracts\Authorization\PolicyDecision\PolicyDecisionPointInterface;
use Limoncello\Auth\Contracts\Authorization\PolicyInformation\ContextInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerInterface;
use function assert;

/**
 * @package Limoncello\Auth
 */
class PolicyDecisionPoint implements PolicyDecisionPointInterface
{
    use DefaultTargetSerializeTrait, LoggerAwareTrait;

    /**
     * @var array
     */
    private $encodePolicySet;

    /**
     * @param PolicySetInterface|array $data
     */
    public function __construct($data)
    {
        $data instanceof PolicySetInterface ? $this->initWithPolicySet($data) : $this->initWithData($data);
    }

    /**
     * @param ContextInterface $context
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function evaluate(ContextInterface $context): array
    {
        $logger = $this->getLogger();

        $set = $this->getEncodePolicySet();

        $name = Encoder::policySetName($set);
        $logger === null ?: $logger->debug("Policy Decision Point evaluates '$name' policy set.");

        $target = Encoder::policySetTarget($set);
        $match  = $this->evaluateTarget($context, $target, $logger);
        $result = BasePolicyOrSetAlgorithm::evaluateItem($context, $match, $this->getEncodePolicySet(), $logger);

        $logger === null ?: $logger->debug("Policy Decision Point evaluated '$name' policy set.");

        return $result;
    }

    /**
     * @return array
     */
    public function getEncodePolicySet(): array
    {
        return $this->encodePolicySet;
    }

    /**
     * @return LoggerInterface|null
     */
    protected function getLogger(): ?LoggerInterface
    {
        return $this->logger;
    }

    /**
     * @param PolicySetInterface $policySet
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    protected function initWithPolicySet(PolicySetInterface $policySet): void
    {
        $this->initWithData(Encoder::encodePolicySet($policySet));
    }

    /**
     * @param array $encodePolicySet
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    protected function initWithData(array $encodePolicySet): void
    {
        assert(Encoder::isPolicySet($encodePolicySet));

        $this->setEncodePolicySet($encodePolicySet);
    }

    /**
     * @param array $encodePolicySet
     */
    protected function setEncodePolicySet(array $encodePolicySet): void
    {
        $this->encodePolicySet = $encodePolicySet;
    }
}