src/Security/Voter/PagePermissionVoter.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Security\Voter;
  5. use App\Entity\User;
  6. use App\Repository\ActionRepository;
  7. use App\Repository\RolePermissionRepository;
  8. use App\Repository\RolesRepository;
  9. use Symfony\Component\HttpFoundation\RequestStack;
  10. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  11. use Symfony\Component\Security\Core\Authorization\Voter\Voter;
  12. use Symfony\Component\Security\Core\Security;
  14. class PagePermissionVoter extends Voter
  15. {
  16.     private RolePermissionRepository $rolePermissionRepository;
  17.     private RolesRepository $rolesRepository;
  18.     private ActionRepository $actionRepository;
  19.     private Security $security;
  20.     private RequestStack $requestStack;
  21.     private ?array $supportedActions = null;
  23.     public function __construct(
  24.         RolePermissionRepository $rolePermissionRepository,
  25.         RolesRepository $rolesRepository,
  26.         ActionRepository $actionRepository,
  27.         Security $security,
  28.         RequestStack $requestStack
  29.     ) {
  30.         $this->rolePermissionRepository = $rolePermissionRepository;
  31.         $this->rolesRepository = $rolesRepository;
  32.         $this->actionRepository = $actionRepository;
  33.         $this->security = $security;
  34.         $this->requestStack = $requestStack;
  35.     }
  37.     /**
  38.      * Récupère dynamiquement les actions depuis la base de données
  39.      */
  40.     private function getSupportedActions(): array
  41.     {
  42.         if ($this->supportedActions === null) {
  43.             $actions = $this->actionRepository->findAll();
  44.             $this->supportedActions = array_map(fn($action) => $action->getCode(), $actions);
  45.         }
  46.         return $this->supportedActions;
  47.     }
  49.     protected function supports(string $attribute, mixed $subject): bool
  50.     {
  51.         // Supporte toutes les actions présentes dans la table Action
  52.         // Subject doit être une string (code de la page) ou null
  53.         return in_array($attribute, $this->getSupportedActions())
  54.             && (is_string($subject) || $subject === null);
  55.     }
  57.     protected function voteOnAttribute(string $attribute, mixed $subject, TokenInterface $token): bool
  58.     {
  59.         $user = $token->getUser();
  61.         // Si l'utilisateur n'est pas connecté, refuser l'accès
  62.         if (!$user instanceof User) {
  63.             return false;
  64.         }
  66.         // Vérifier si l'utilisateur est super admin
  67.         if (in_array('ROLE_SUPER_ADMIN', $user->getRoles())) {
  68.             return true;
  69.         }
  71.         // $subject = code de la page (ex: 'pages', 'users', 'blog_posts')
  72.         $pageCode = $subject;
  74.         if (!$pageCode) {
  75.             return false;
  76.         }
  78.         // Rendre insensible à la casse
  79.         $pageCode = strtolower($pageCode);
  81.         // Récupérer les permissions depuis la session
  82.         $session = $this->requestStack->getSession();
  83.         $userPermissions = $session->get('user_permissions', []);
  85.         // Si pas en session, charger depuis la BDD (fallback)
  86.         if (empty($userPermissions)) {
  87.             $userPermissions = $this->loadUserPermissionsFromDatabase($user);
  88.             $session->set('user_permissions', $userPermissions);
  89.         }
  91.         // Vérifier si la permission existe
  92.         return isset($userPermissions[$pageCode]) && 
  93.                in_array($attribute, $userPermissions[$pageCode]);
  94.     }
  96.     private function loadUserPermissionsFromDatabase(User $user): array
  97.     {
  98.         $permissions = [];
  99.         $userRoles = $user->getRoles();
  101.         foreach ($userRoles as $roleString) {
  102.             $roleEntity = $this->rolesRepository->findOneBy(['code' => $roleString]);
  103.             
  104.             if (!$roleEntity) {
  105.                 continue;
  106.             }
  108.             $rolePermissions = $this->rolePermissionRepository->findBy(['role' => $roleEntity]);
  110.             foreach ($rolePermissions as $rolePermission) {
  111.                 $permission = $rolePermission->getPermission();
  112.                 
  113.                 if (!$permission) {
  114.                     continue;
  115.                 }
  117.                 $page = $permission->getPage();
  118.                 $action = $permission->getAction();
  120.                 if ($page && $action) {
  121.                     $pageCode = strtolower($page->getCode());
  122.                     $actionCode = strtoupper($action->getCode());
  124.                     if (!isset($permissions[$pageCode])) {
  125.                         $permissions[$pageCode] = [];
  126.                     }
  128.                     if (!in_array($actionCode, $permissions[$pageCode])) {
  129.                         $permissions[$pageCode][] = $actionCode;
  130.                     }
  131.                 }
  132.             }
  133.         }
  135.         return $permissions;
  136.     }
  137. }