vendor/symfony/symfony/src/Symfony/Component/Security/Core/Authorization/AccessDecisionManager.php line 88

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;
  16. use Symfony\Component\Security\Core\Exception\LogicException;
  18. /**
  19.  * AccessDecisionManager is the base class for all access decision managers
  20.  * that use decision voters.
  21.  *
  22.  * @author Fabien Potencier <fabien@symfony.com>
  23.  */
  24. class AccessDecisionManager implements AccessDecisionManagerInterface
  25. {
  26.     const STRATEGY_AFFIRMATIVE = 'affirmative';
  27.     const STRATEGY_CONSENSUS = 'consensus';
  28.     const STRATEGY_UNANIMOUS = 'unanimous';
  30.     private $voters;
  31.     private $strategy;
  32.     private $allowIfAllAbstainDecisions;
  33.     private $allowIfEqualGrantedDeniedDecisions;
  35.     /**
  36.      * @param iterable|VoterInterface[] $voters                             An iterator of VoterInterface instances
  37.      * @param string                    $strategy                           The vote strategy
  38.      * @param bool                      $allowIfAllAbstainDecisions         Whether to grant access if all voters abstained or not
  39.      * @param bool                      $allowIfEqualGrantedDeniedDecisions Whether to grant access if result are equals
  40.      *
  41.      * @throws \InvalidArgumentException
  42.      */
  43.     public function __construct($voters = [], $strategy = self::STRATEGY_AFFIRMATIVE, $allowIfAllAbstainDecisions = false, $allowIfEqualGrantedDeniedDecisions = true)
  44.     {
  45.         $strategyMethod = 'decide'.ucfirst($strategy);
  46.         if ('' === $strategy || !\is_callable([$this, $strategyMethod])) {
  47.             throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  48.         }
  50.         $this->voters = $voters;
  51.         $this->strategy = $strategyMethod;
  52.         $this->allowIfAllAbstainDecisions = (bool) $allowIfAllAbstainDecisions;
  53.         $this->allowIfEqualGrantedDeniedDecisions = (bool) $allowIfEqualGrantedDeniedDecisions;
  54.     }
  56.     /**
  57.      * Configures the voters.
  58.      *
  59.      * @param VoterInterface[] $voters An array of VoterInterface instances
  60.      *
  61.      * @deprecated since version 3.3, to be removed in 4.0. Pass the voters to the constructor instead.
  62.      */
  63.     public function setVoters(array $voters)
  64.     {
  65.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 3.3 and will be removed in 4.0. Pass the voters to the constructor instead.', __METHOD__), \E_USER_DEPRECATED);
  67.         $this->voters = $voters;
  68.     }
  70.     /**
  71.      * {@inheritdoc}
  72.      */
  73.     public function decide(TokenInterface $token, array $attributes, $object = null)
  74.     {
  75.         return $this->{$this->strategy}($token, $attributes, $object);
  76.     }
  78.     /**
  79.      * Grants access if any voter returns an affirmative response.
  80.      *
  81.      * If all voters abstained from voting, the decision will be based on the
  82.      * allowIfAllAbstainDecisions property value (defaults to false).
  83.      */
  84.     private function decideAffirmative(TokenInterface $token, array $attributes, $object = null)
  85.     {
  86.         $deny = 0;
  87.         foreach ($this->voters as $voter) {
  88.             $result = $this->vote($voter, $token, $object, $attributes);
  90.             if (VoterInterface::ACCESS_GRANTED === $result) {
  91.                 return true;
  92.             }
  94.             if (VoterInterface::ACCESS_DENIED === $result) {
  95.                 ++$deny;
  96.             }
  97.         }
  99.         if ($deny > 0) {
  100.             return false;
  101.         }
  103.         return $this->allowIfAllAbstainDecisions;
  104.     }
  106.     /**
  107.      * Grants access if there is consensus of granted against denied responses.
  108.      *
  109.      * Consensus means majority-rule (ignoring abstains) rather than unanimous
  110.      * agreement (ignoring abstains). If you require unanimity, see
  111.      * UnanimousBased.
  112.      *
  113.      * If there were an equal number of grant and deny votes, the decision will
  114.      * be based on the allowIfEqualGrantedDeniedDecisions property value
  115.      * (defaults to true).
  116.      *
  117.      * If all voters abstained from voting, the decision will be based on the
  118.      * allowIfAllAbstainDecisions property value (defaults to false).
  119.      */
  120.     private function decideConsensus(TokenInterface $token, array $attributes, $object = null)
  121.     {
  122.         $grant = 0;
  123.         $deny = 0;
  124.         foreach ($this->voters as $voter) {
  125.             $result = $this->vote($voter, $token, $object, $attributes);
  127.             if (VoterInterface::ACCESS_GRANTED === $result) {
  128.                 ++$grant;
  129.             } elseif (VoterInterface::ACCESS_DENIED === $result) {
  130.                 ++$deny;
  131.             }
  132.         }
  134.         if ($grant > $deny) {
  135.             return true;
  136.         }
  138.         if ($deny > $grant) {
  139.             return false;
  140.         }
  142.         if ($grant > 0) {
  143.             return $this->allowIfEqualGrantedDeniedDecisions;
  144.         }
  146.         return $this->allowIfAllAbstainDecisions;
  147.     }
  149.     /**
  150.      * Grants access if only grant (or abstain) votes were received.
  151.      *
  152.      * If all voters abstained from voting, the decision will be based on the
  153.      * allowIfAllAbstainDecisions property value (defaults to false).
  154.      */
  155.     private function decideUnanimous(TokenInterface $token, array $attributes, $object = null)
  156.     {
  157.         $grant = 0;
  158.         foreach ($this->voters as $voter) {
  159.             foreach ($attributes as $attribute) {
  160.                 $result = $this->vote($voter, $token, $object, [$attribute]);
  162.                 if (VoterInterface::ACCESS_DENIED === $result) {
  163.                     return false;
  164.                 }
  166.                 if (VoterInterface::ACCESS_GRANTED === $result) {
  167.                     ++$grant;
  168.                 }
  169.             }
  170.         }
  172.         // no deny votes
  173.         if ($grant > 0) {
  174.             return true;
  175.         }
  177.         return $this->allowIfAllAbstainDecisions;
  178.     }
  180.     /**
  181.      * TokenInterface vote proxy method.
  182.      *
  183.      * Acts as a BC layer when the VoterInterface is not implemented on the voter.
  184.      *
  185.      * @deprecated as of 3.4 and will be removed in 4.0. Call the voter directly as the instance will always be a VoterInterface
  186.      */
  187.     private function vote($voter, TokenInterface $token, $subject, $attributes)
  188.     {
  189.         if ($voter instanceof VoterInterface) {
  190.             return $voter->vote($token, $subject, $attributes);
  191.         }
  193.         if (method_exists($voter, 'vote')) {
  194.             @trigger_error(sprintf('Calling vote() on an voter without %1$s is deprecated as of 3.4 and will be removed in 4.0. Implement the %1$s on your voter.', VoterInterface::class), \E_USER_DEPRECATED);
  196.             // making the assumption that the signature matches
  197.             return $voter->vote($token, $subject, $attributes);
  198.         }
  200.         throw new LogicException(sprintf('"%s" should implement the "%s" interface when used as voter.', \get_class($voter), VoterInterface::class));
  201.     }
  202. }