Jak zmienić hierarchię ról w Symfony2?

Miałem zrobić to samo jak zIs (aby zapisać Rolehierarchię w bazie danych), ale nie mogę załadować pełnej hierarchii ról wewnątrz konstruktora, tak jak zIs, ponieważ musiałem załadować niestandardowy filtr doctrine wewnątrz zdarzenia kernel.request. Konstruktor będzie nazywany przed kernel.request, więc nie było to dla mnie rozwiązaniem.

Dlatego sprawdziłem komponent bezpieczeństwa i dowiedziałem się, że Symfony wywołuje Niestandardowy Voter, aby sprawdzić roleHierarchy Według użytkowników rola:

namespace Symfony\Component\Security\Core\Authorization\Voter;

use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Role\RoleHierarchyInterface;

/**
 * RoleHierarchyVoter uses a RoleHierarchy to determine the roles granted to
 * the user before voting.
 *
 * @author Fabien Potencier <[email protected]>
 */
class RoleHierarchyVoter extends RoleVoter
{
    private $roleHierarchy;

    public function __construct(RoleHierarchyInterface $roleHierarchy, $prefix = 'ROLE_')
    {
        $this->roleHierarchy = $roleHierarchy;

        parent::__construct($prefix);
    }

    /**
     * {@inheritdoc}
     */
    protected function extractRoles(TokenInterface $token)
    {
        return $this->roleHierarchy->getReachableRoles($token->getRoles());
    }
}

Metoda getReachableRoles zwraca wszystkie role, którymi może być użytkownik. Na przykład:

           ROLE_ADMIN
         /             \
     ROLE_SUPERVISIOR  ROLE_BLA
        |               |
     ROLE_BRANCH       ROLE_BLA2
       |
     ROLE_EMP

or in Yaml:
ROLE_ADMIN:       [ ROLE_SUPERVISIOR, ROLE_BLA ]
ROLE_SUPERVISIOR: [ ROLE_BRANCH ]
ROLE_BLA:         [ ROLE_BLA2 ]

Ponadto ten zwyczaj zostanie wyłączony, jeśli w security.yaml

private function createRoleHierarchy($config, ContainerBuilder $container)
    {
        if (!isset($config['role_hierarchy'])) {
            $container->removeDefinition('security.access.role_hierarchy_voter');

            return;
        }

        $container->setParameter('security.role_hierarchy.roles', $config['role_hierarchy']);
        $container->removeDefinition('security.access.simple_role_voter');
    }

Aby rozwiązać mój problem stworzyłem własny, niestandardowy głos i rozszerzyłem RoleVoter-Klasa też:

use Symfony\Component\Security\Core\Authorization\Voter\RoleVoter;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Acme\Foundation\UserBundle\Entity\Group;
use Doctrine\ORM\EntityManager;

class RoleHierarchyVoter extends RoleVoter {

    private $em;

    public function __construct(EntityManager $em, $prefix = 'ROLE_') {

        $this->em = $em;

        parent::__construct($prefix);
    }

    /**
     * {@inheritdoc}
     */
    protected function extractRoles(TokenInterface $token) {

        $group = $token->getUser()->getGroup();

        return $this->getReachableRoles($group);
    }

    public function getReachableRoles(Group $group, &$groups = array()) {

        $groups[] = $group;

        $children = $this->em->getRepository('AcmeFoundationUserBundle:Group')->createQueryBuilder('g')
                        ->where('g.parent = :group')
                        ->setParameter('group', $group->getId())
                        ->getQuery()
                        ->getResult();

        foreach($children as $child) {
            $this->getReachableRoles($child, $groups);
        }

        return $groups;
    }
}

Jedna uwaga: moja konfiguracja jest podobna do zls. Moja definicja roli (w moim przypadku nazwałem ją grupą):

Acme\Foundation\UserBundle\Entity\Group:
    type: entity
    table: sec_groups
    id: 
        id:
            type: integer
            generator: { strategy: AUTO }
    fields:
        name:
            type: string
            length: 50
        role:
            type: string
            length: 20
    manyToOne:
        parent:
            targetEntity: Group

I userdefinition:

Acme\Foundation\UserBundle\Entity\User:
    type: entity
    table: sec_users
    repositoryClass: Acme\Foundation\UserBundle\Entity\UserRepository
    id:
        id:
            type: integer
            generator: { strategy: AUTO }
    fields:
        username:
            type: string
            length: 30
        salt:
            type: string
            length: 32
        password:
            type: string
            length: 100
        isActive:
            type: boolean
            column: is_active
    manyToOne:
        group:
            targetEntity: Group
            joinColumn:
                name: group_id
                referencedColumnName: id
                nullable: false

Opracowałem pakiet.

Znajdziesz go na https://github.com/Spomky-Labs/RoleHierarchyBundle

Moje rozwiązanie zostało zainspirowane rozwiązaniem dostarczonym przez zls. Jego rozwiązanie działało dla mnie doskonale, ale relacja jeden do wielu między rolami oznaczała posiadanie jednego ogromnego drzewa ról, które stało się trudne do utrzymania. Ponadto, problem może wystąpić, jeśli dwie różne role chcą dziedziczyć jedną tę samą rolę (ponieważ może być tylko jeden rodzic). Dlatego postanowiłem stworzyć rozwiązanie wiele do wielu. Zamiast mieć tylko rodzica w klasie ról, najpierw umieściłem to w roli klasa:

/**
 * @ORM\ManyToMany(targetEntity="Role")
 * @ORM\JoinTable(name="role_permission",
 *      joinColumns={@ORM\JoinColumn(name="role_id", referencedColumnName="id")},
 *      inverseJoinColumns={@ORM\JoinColumn(name="permission_id", referencedColumnName="id")}
 *      )
 */
protected $children;

Potem przepisałem funkcję buildRolesTree TAK:

private function buildRolesTree()
{
    $hierarchy = array();
    $roles = $this->em->createQuery('select r, p from AltGrBaseBundle:Role r JOIN r.children p')->execute();

    foreach ($roles as $role)
    {
        /* @var $role Role */
        if (count($role->getChildren()) > 0)
        {
            $roleChildren = array();

            foreach ($role->getChildren() as $child)
            {
                /* @var $child Role */
                $roleChildren[] = $child->getRole();
            }

            $hierarchy[$role->getRole()] = $roleChildren;
        }
    }

    return $hierarchy;
}

Rezultatem jest możliwość stworzenia kilku łatwych w utrzymaniu drzew. Na przykład możesz mieć drzewo ról definiujące rolę ROLE_SUPERADMIN i całkowicie oddzielne drzewo definiujące rolę ROLE_ADMIN z kilkoma rolami współdzielonymi między nimi. Chociaż należy unikać połączeń kołowych (role powinny być ułożone jak drzewa, bez żadnych połączeń kołowych między nimi), nie powinno być problemy, jeśli tak się stanie. Nie testowałem tego, ale przechodząc przez kod buildRoleMap, jest oczywiste, że wyrzuca wszystkie duplikaty. Powinno to również oznaczać, że nie utknie w niekończących się pętlach, jeśli wystąpi połączenie kołowe, ale to zdecydowanie wymaga więcej testów.

Ponieważ hierarchia ról nie zmienia się często, jest to szybka Klasa do buforowania do memcached.

<?php

namespace .....;

use Symfony\Component\Security\Core\Role\Role;
use Symfony\Component\Security\Core\Role\RoleHierarchyInterface;
use Lsw\MemcacheBundle\Cache\MemcacheInterface;

/**
 * RoleHierarchy defines a role hierarchy.
 */
class RoleHierarchy implements RoleHierarchyInterface
{
    /**
     *
     * @var MemcacheInterface 
     */
    private $memcache;

    /**
     *
     * @var array 
     */
    private $hierarchy;

    /**
     *
     * @var array 
     */
    protected $map;

    /**
     * Constructor.
     *
     * @param array $hierarchy An array defining the hierarchy
     */
    public function __construct(array $hierarchy, MemcacheInterface $memcache)
    {
        $this->hierarchy = $hierarchy;

        $roleMap = $memcache->get('roleMap');

        if ($roleMap) {
            $this->map = unserialize($roleMap);
        } else {
            $this->buildRoleMap();
            // cache to memcache
            $memcache->set('roleMap', serialize($this->map));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getReachableRoles(array $roles)
    {
        $reachableRoles = $roles;
        foreach ($roles as $role) {
            if (!isset($this->map[$role->getRole()])) {
                continue;
            }

            foreach ($this->map[$role->getRole()] as $r) {
                $reachableRoles[] = new Role($r);
            }
        }

        return $reachableRoles;
    }

    protected function buildRoleMap()
    {
        $this->map = array();
        foreach ($this->hierarchy as $main => $roles) {
            $this->map[$main] = $roles;
            $visited = array();
            $additionalRoles = $roles;
            while ($role = array_shift($additionalRoles)) {
                if (!isset($this->hierarchy[$role])) {
                    continue;
                }

                $visited[] = $role;
                $this->map[$main] = array_unique(array_merge($this->map[$main], $this->hierarchy[$role]));
                $additionalRoles = array_merge($additionalRoles, array_diff($this->hierarchy[$role], $visited));
            }
        }
    }
}

Mam nadzieję, że to ci pomoże.

function getRoles()
{

  //  return array(1=>'ROLE_ADMIN',2=>'ROLE_USER'); 
   return array(new UserRole($this));
}

Możesz uzyskać dobry pomysł z, Gdzie zdefiniować role bezpieczeństwa?

Http://php-and-symfony.matthiasnoback.nl / (2012 Lipiec 28)