vendor/symfony/security-core/Authorization/AccessDecisionManager.php line 60

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Security\Core\Authorization;
  14. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  15. use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
  17. /**
  18.  * AccessDecisionManager is the base class for all access decision managers
  19.  * that use decision voters.
  20.  *
  21.  * @author Fabien Potencier <fabien@symfony.com>
  22.  */
  23. class AccessDecisionManager implements AccessDecisionManagerInterface
  24. {
  25.     public const STRATEGY_AFFIRMATIVE = 'affirmative';
  26.     public const STRATEGY_CONSENSUS = 'consensus';
  27.     public const STRATEGY_UNANIMOUS = 'unanimous';
  29.     private $voters;
  30.     private $strategy;
  31.     private $allowIfAllAbstainDecisions;
  32.     private $allowIfEqualGrantedDeniedDecisions;
  34.     /**
  35.      * @param iterable|VoterInterface[] $voters                             An array or an iterator of VoterInterface instances
  36.      * @param string                    $strategy                           The vote strategy
  37.      * @param bool                      $allowIfAllAbstainDecisions         Whether to grant access if all voters abstained or not
  38.      * @param bool                      $allowIfEqualGrantedDeniedDecisions Whether to grant access if result are equals
  39.      *
  40.      * @throws \InvalidArgumentException
  41.      */
  42.     public function __construct(iterable $voters = [], string $strategy = self::STRATEGY_AFFIRMATIVE, bool $allowIfAllAbstainDecisions = false, bool $allowIfEqualGrantedDeniedDecisions = true)
  43.     {
  44.         $strategyMethod = 'decide'.ucfirst($strategy);
  45.         if ('' === $strategy || !\is_callable([$this, $strategyMethod])) {
  46.             throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  47.         }
  49.         $this->voters = $voters;
  50.         $this->strategy = $strategyMethod;
  51.         $this->allowIfAllAbstainDecisions = $allowIfAllAbstainDecisions;
  52.         $this->allowIfEqualGrantedDeniedDecisions = $allowIfEqualGrantedDeniedDecisions;
  53.     }
  55.     /**
  56.      * @param bool $allowMultipleAttributes Whether to allow passing multiple values to the $attributes array
  57.      *
  58.      * {@inheritdoc}
  59.      */
  60.     public function decide(TokenInterface $token, array $attributes, $object = null/*, bool $allowMultipleAttributes = false*/)
  61.     {
  62.         $allowMultipleAttributes = 3 < \func_num_args() && func_get_arg(3);
  64.         // Special case for AccessListener, do not remove the right side of the condition before 6.0
  65.         if (\count($attributes) > 1 && !$allowMultipleAttributes) {
  66.             @trigger_error(sprintf('Passing more than one Security attribute to "%s()" is deprecated since Symfony 4.4. Use multiple "decide()" calls or the expression language (e.g. "is_granted(...) or is_granted(...)") instead.', __METHOD__), \E_USER_DEPRECATED);
  67.         }
  69.         return $this->{$this->strategy}($token, $attributes, $object);
  70.     }
  72.     /**
  73.      * Grants access if any voter returns an affirmative response.
  74.      *
  75.      * If all voters abstained from voting, the decision will be based on the
  76.      * allowIfAllAbstainDecisions property value (defaults to false).
  77.      */
  78.     private function decideAffirmative(TokenInterface $token, array $attributes, $object = null): bool
  79.     {
  80.         $deny = 0;
  81.         foreach ($this->voters as $voter) {
  82.             $result = $voter->vote($token, $object, $attributes);
  84.             if (VoterInterface::ACCESS_GRANTED === $result) {
  85.                 return true;
  86.             }
  88.             if (VoterInterface::ACCESS_DENIED === $result) {
  89.                 ++$deny;
  90.             }
  91.         }
  93.         if ($deny > 0) {
  94.             return false;
  95.         }
  97.         return $this->allowIfAllAbstainDecisions;
  98.     }
  100.     /**
  101.      * Grants access if there is consensus of granted against denied responses.
  102.      *
  103.      * Consensus means majority-rule (ignoring abstains) rather than unanimous
  104.      * agreement (ignoring abstains). If you require unanimity, see
  105.      * UnanimousBased.
  106.      *
  107.      * If there were an equal number of grant and deny votes, the decision will
  108.      * be based on the allowIfEqualGrantedDeniedDecisions property value
  109.      * (defaults to true).
  110.      *
  111.      * If all voters abstained from voting, the decision will be based on the
  112.      * allowIfAllAbstainDecisions property value (defaults to false).
  113.      */
  114.     private function decideConsensus(TokenInterface $token, array $attributes, $object = null): bool
  115.     {
  116.         $grant = 0;
  117.         $deny = 0;
  118.         foreach ($this->voters as $voter) {
  119.             $result = $voter->vote($token, $object, $attributes);
  121.             if (VoterInterface::ACCESS_GRANTED === $result) {
  122.                 ++$grant;
  123.             } elseif (VoterInterface::ACCESS_DENIED === $result) {
  124.                 ++$deny;
  125.             }
  126.         }
  128.         if ($grant > $deny) {
  129.             return true;
  130.         }
  132.         if ($deny > $grant) {
  133.             return false;
  134.         }
  136.         if ($grant > 0) {
  137.             return $this->allowIfEqualGrantedDeniedDecisions;
  138.         }
  140.         return $this->allowIfAllAbstainDecisions;
  141.     }
  143.     /**
  144.      * Grants access if only grant (or abstain) votes were received.
  145.      *
  146.      * If all voters abstained from voting, the decision will be based on the
  147.      * allowIfAllAbstainDecisions property value (defaults to false).
  148.      */
  149.     private function decideUnanimous(TokenInterface $token, array $attributes, $object = null): bool
  150.     {
  151.         $grant = 0;
  152.         foreach ($this->voters as $voter) {
  153.             foreach ($attributes as $attribute) {
  154.                 $result = $voter->vote($token, $object, [$attribute]);
  156.                 if (VoterInterface::ACCESS_DENIED === $result) {
  157.                     return false;
  158.                 }
  160.                 if (VoterInterface::ACCESS_GRANTED === $result) {
  161.                     ++$grant;
  162.                 }
  163.             }
  164.         }
  166.         // no deny votes
  167.         if ($grant > 0) {
  168.             return true;
  169.         }
  171.         return $this->allowIfAllAbstainDecisions;
  172.     }
  173. }