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.     const STRATEGY_AFFIRMATIVE = 'affirmative';
  26.     const STRATEGY_CONSENSUS = 'consensus';
  27.     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.      * {@inheritdoc}
  57.      */
  58.     public function decide(TokenInterface $token, array $attributes, $object = null)
  59.     {
  60.         return $this->{$this->strategy}($token, $attributes, $object);
  61.     }
  63.     /**
  64.      * Grants access if any voter returns an affirmative response.
  65.      *
  66.      * If all voters abstained from voting, the decision will be based on the
  67.      * allowIfAllAbstainDecisions property value (defaults to false).
  68.      */
  69.     private function decideAffirmative(TokenInterface $token, array $attributes, $object = null)
  70.     {
  71.         $deny = 0;
  72.         foreach ($this->voters as $voter) {
  73.             $result = $voter->vote($token, $object, $attributes);
  74.             switch ($result) {
  75.                 case VoterInterface::ACCESS_GRANTED:
  76.                     return true;
  78.                 case VoterInterface::ACCESS_DENIED:
  79.                     ++$deny;
  81.                     break;
  83.                 default:
  84.                     break;
  85.             }
  86.         }
  88.         if ($deny > 0) {
  89.             return false;
  90.         }
  92.         return $this->allowIfAllAbstainDecisions;
  93.     }
  95.     /**
  96.      * Grants access if there is consensus of granted against denied responses.
  97.      *
  98.      * Consensus means majority-rule (ignoring abstains) rather than unanimous
  99.      * agreement (ignoring abstains). If you require unanimity, see
  100.      * UnanimousBased.
  101.      *
  102.      * If there were an equal number of grant and deny votes, the decision will
  103.      * be based on the allowIfEqualGrantedDeniedDecisions property value
  104.      * (defaults to true).
  105.      *
  106.      * If all voters abstained from voting, the decision will be based on the
  107.      * allowIfAllAbstainDecisions property value (defaults to false).
  108.      */
  109.     private function decideConsensus(TokenInterface $token, array $attributes, $object = null)
  110.     {
  111.         $grant = 0;
  112.         $deny = 0;
  113.         foreach ($this->voters as $voter) {
  114.             $result = $voter->vote($token, $object, $attributes);
  116.             switch ($result) {
  117.                 case VoterInterface::ACCESS_GRANTED:
  118.                     ++$grant;
  120.                     break;
  122.                 case VoterInterface::ACCESS_DENIED:
  123.                     ++$deny;
  125.                     break;
  126.             }
  127.         }
  129.         if ($grant > $deny) {
  130.             return true;
  131.         }
  133.         if ($deny > $grant) {
  134.             return false;
  135.         }
  137.         if ($grant > 0) {
  138.             return $this->allowIfEqualGrantedDeniedDecisions;
  139.         }
  141.         return $this->allowIfAllAbstainDecisions;
  142.     }
  144.     /**
  145.      * Grants access if only grant (or abstain) votes were received.
  146.      *
  147.      * If all voters abstained from voting, the decision will be based on the
  148.      * allowIfAllAbstainDecisions property value (defaults to false).
  149.      */
  150.     private function decideUnanimous(TokenInterface $token, array $attributes, $object = null)
  151.     {
  152.         $grant = 0;
  153.         foreach ($this->voters as $voter) {
  154.             foreach ($attributes as $attribute) {
  155.                 $result = $voter->vote($token, $object, [$attribute]);
  157.                 switch ($result) {
  158.                     case VoterInterface::ACCESS_GRANTED:
  159.                         ++$grant;
  161.                         break;
  163.                     case VoterInterface::ACCESS_DENIED:
  164.                         return false;
  166.                     default:
  167.                         break;
  168.                 }
  169.             }
  170.         }
  172.         // no deny votes
  173.         if ($grant > 0) {
  174.             return true;
  175.         }
  177.         return $this->allowIfAllAbstainDecisions;
  178.     }
  179. }