Вызов symfony2 is_granted в избирателе: как избежать бесконечного цикла?

Так что я нашел ответ благодаря @Cerad:

Точность: вы не можете расширить класс abstractVoter, потому что вам нужен доступ к токену. Просто реализуйте тот же интерфейс, который реализует абстрактный избиратель.

Cerad предложение: Пользовательская иерархия ролей Symfony2

Мой :

<?php

namespace AppBundle\Security\Voter;

use AppBundle\Entity\User\Associate;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
use Symfony\Component\Security\Core\Role\RoleHierarchy;
use Symfony\Component\Security\Core\User\UserInterface;

class ManagerVoter implements VoterInterface
{
const SELECT_ASSOCIATES = 'select_associates';

private $roleHierarchy;

public function __construct(RoleHierarchy $roleHierarchy)
{
$this->roleHierarchy = $roleHierarchy;
}

protected function hasRole(TokenInterface $token, $targetRole)
{
$reachableRoles = $this->roleHierarchy->getReachableRoles($token->getRoles());
foreach($reachableRoles as $role)
{
if ($role->getRole() == $targetRole) return true;
}
return false;
}

protected function getSupportedClasses()
{
return array(
'AppBundle\Entity\User\Associate',
);
}

protected function getSupportedAttributes()
{
return array(self::SELECT_ASSOCIATES);
}

/**
* Iteratively check all given attributes by calling isGranted
*
* This method terminates as soon as it is able to return ACCESS_GRANTED
* If at least one attribute is supported, but access not granted, then ACCESS_DENIED is returned
* Otherwise it will return ACCESS_ABSTAIN
*
* @param TokenInterface $token      A TokenInterface instance
* @param object         $object     The object to secure
* @param array          $attributes An array of attributes associated with the method being invoked
*
* @return int     either ACCESS_GRANTED, ACCESS_ABSTAIN, or ACCESS_DENIED
*/
public function vote(TokenInterface $token, $object, array $attributes)
{
if (!$object || !$this->supportsClass(get_class($object))) {
return self::ACCESS_ABSTAIN;
}

// abstain vote by default in case none of the attributes are supported
$vote = self::ACCESS_ABSTAIN;

foreach ($attributes as $attribute) {
if (!$this->supportsAttribute($attribute)) {
continue;
}

// as soon as at least one attribute is supported, default is to deny access
$vote = self::ACCESS_DENIED;

if ($this->isGranted($attribute, $object, $token)) {
// grant access as soon as at least one voter returns a positive response
return self::ACCESS_GRANTED;
}
}

return $vote;
}/**
* Perform a single access check operation on a given attribute, object and (optionally) user
* It is safe to assume that $attribute and $object's class pass supportsAttribute/supportsClass
* $user can be one of the following:
*   a UserInterface object (fully authenticated user)
*   a string               (anonymously authenticated user)
*
* @param string $attribute
* @param object $object
* @param $token
* @internal param string|UserInterface $user
*
* @return bool
*/
protected function isGranted($attribute, $object, TokenInterface $token)
{
$user = $token->getUser();
/** @var $object Associate */
$associateRoles = $object->getRoles();

// make sure there is a user object (i.e. that the user is logged in)
if (!$user instanceof UserInterface) {
return false;
}

//        if ($this->hasRole($token, 'ROLE_ADMIN'))
//        {
//            return true;
//        }

if ($attribute == self::SELECT_ASSOCIATES) {

if (in_array('ROLE_COMPANY_STAFF',$associateRoles))
{
if ($this->hasRole($token, 'ROLE_COMPANY_MANAGER'))
{
return true;
}
}
elseif (in_array('ROLE_BOUTIQUE_STAFF',$associateRoles))
{
if ($this->hasRole($token, 'ROLE_BOUTIQUE_MANAGER'))
{
return true;
}
}
elseif (in_array('ROLE_SCHOOL_STAFF',$associateRoles))
{
if ($this->hasRole($token, 'ROLE_PROFESSOR'))
{
return true;
}
}
}

return false;
}/**
* {@inheritdoc}
*/
public function supportsAttribute($attribute)
{
return in_array($attribute, $this->getSupportedAttributes());
}

/**
* {@inheritdoc}
*/
public function supportsClass($class)
{
foreach ($this->getSupportedClasses() as $supportedClass) {
if ($supportedClass === $class || is_subclass_of($class, $supportedClass)) {
return true;
}
}

return false;
}
}