vendor/zendframework/zend-permissions-acl/src/Assertion/AssertionAggregate.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9 namespace Zend\Permissions\Acl\Assertion;
  10
  11 use Zend\Permissions\Acl\Acl;
  12 use Zend\Permissions\Acl\Exception\InvalidArgumentException;
  13 use Zend\Permissions\Acl\Exception\RuntimeException;
  14 use Zend\Permissions\Acl\Resource\ResourceInterface;
  15 use Zend\Permissions\Acl\Role\RoleInterface;
  16
  17 class AssertionAggregate implements AssertionInterface
  18 {
  19     const MODE_ALL = 'all';
  20
  21     const MODE_AT_LEAST_ONE = 'at_least_one';
  22
  23     protected $assertions = [];
  24
  25     /**
  26      *
  27      * @var $manager AssertionManager
  28      */
  29     protected $assertionManager;
  30
  31     protected $mode = self::MODE_ALL;
  32
  33     /**
  34      * Stacks an assertion in aggregate
  35      *
  36      * @param AssertionInterface|string $assertion
  37      *    if string, must match a AssertionManager declared service (checked later)
  38      *
  39      * @return self
  40      */
  41     public function addAssertion($assertion)
  42     {
  43         $this->assertions[] = $assertion;
  44
  45         return $this;
  46     }
  47
  48     public function addAssertions(array $assertions)
  49     {
  50         foreach ($assertions as $assertion) {
  51             $this->addAssertion($assertion);
  52         }
  53
  54         return $this;
  55     }
  56
  57     /**
  58      * Empties assertions stack
  59      *
  60      * @return self
  61      */
  62     public function clearAssertions()
  63     {
  64         $this->assertions = [];
  65
  66         return $this;
  67     }
  68
  69     /**
  70      *
  71      * @param AssertionManager $manager
  72      *
  73      * @return self
  74      */
  75     public function setAssertionManager(AssertionManager $manager)
  76     {
  77         $this->assertionManager = $manager;
  78
  79         return $this;
  80     }
  81
  82     public function getAssertionManager()
  83     {
  84         return $this->assertionManager;
  85     }
  86
  87     /**
  88      * Set assertion chain behavior
  89      *
  90      * AssertionAggregate should assert to true when:
  91      *
  92      * - all assertions are true with MODE_ALL
  93      * - at least one assertion is true with MODE_AT_LEAST_ONE
  94      *
  95      * @param string $mode
  96      *    indicates how assertion chain result should interpreted (either 'all' or 'at_least_one')
  97      * @throws InvalidArgumentException
  98      *
  99      * @return self
 100      */
 101     public function setMode($mode)
 102     {
 103         if ($mode != self::MODE_ALL && $mode != self::MODE_AT_LEAST_ONE) {
 104             throw new InvalidArgumentException('invalid assertion aggregate mode');
 105         }
 106
 107         $this->mode = $mode;
 108
 109         return $this;
 110     }
 111
 112     /**
 113      * Return current mode
 114      *
 115      * @return string
 116      */
 117     public function getMode()
 118     {
 119         return $this->mode;
 120     }
 121
 122     /**
 123      * @see \Zend\Permissions\Acl\Assertion\AssertionInterface::assert()
 124      *
 125      * @throws RuntimeException
 126      * @return bool
 127      */
 128     public function assert(
 129         Acl $acl,
 130         RoleInterface $role = null,
 131         ResourceInterface $resource = null,
 132         $privilege = null
 133     ) {
 134         // check if assertions are set
 135         if (! $this->assertions) {
 136             throw new RuntimeException('no assertion have been aggregated to this AssertionAggregate');
 137         }
 138
 139         foreach ($this->assertions as $assertion) {
 140             // jit assertion mloading
 141             if (! $assertion instanceof AssertionInterface) {
 142                 if (class_exists($assertion)) {
 143                     $assertion = new $assertion();
 144                 } else {
 145                     if ($manager = $this->getAssertionManager()) {
 146                         try {
 147                             $assertion = $manager->get($assertion);
 148                         } catch (\Exception $e) {
 149                             throw new Exception\InvalidAssertionException(
 150                                 'assertion "'
 151                                 . $assertion
 152                                 . '" is not defined in assertion manager'
 153                             );
 154                         }
 155                     } else {
 156                         throw new RuntimeException('no assertion manager is set - cannot look up for assertions');
 157                     }
 158                 }
 159             }
 160
 161             $result = (bool) $assertion->assert($acl, $role, $resource, $privilege);
 162
 163             if ($this->getMode() == self::MODE_ALL && ! $result) {
 164                 // on false is enough
 165                 return false;
 166             }
 167
 168             if ($this->getMode() == self::MODE_AT_LEAST_ONE && $result) {
 169                 // one true is enough
 170                 return true;
 171             }
 172         }
 173
 174         if ($this->getMode() == self::MODE_ALL) {
 175             // none of the assertions returned false
 176             return true;
 177         } else {
 178             return false;
 179         }
 180     }
 181 }