src/Manager/User/PermissionManager.php line 44

Open in your IDE?
  1. <?php
  3. namespace App\Manager\User;
  5. use App\Annotations\HasPermission;
  6. use App\Annotations\PermissionKey;
  7. use App\Entity\Menu;
  8. use App\Entity\User\User;
  9. use Doctrine\Common\Annotations\Reader;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Symfony\Component\Routing\Annotation\Route;
  12. use Symfony\Component\Routing\RouterInterface;
  13. use Symfony\Component\Security\Core\Security;
  15. class PermissionManager
  16. {
  17.     private Security $security;
  18.     private Reader $annotationReader;
  19.     private RouterInterface $router;
  20.     private EntityManagerInterface $entityManager;
  22.     public function __construct(Security $security, Reader $annotationReader, RouterInterface $router,
  23.                                 EntityManagerInterface $entityManager)
  24.     {
  25.         $this->security = $security;
  26.         $this->annotationReader = $annotationReader;
  27.         $this->router = $router;
  28.         $this->entityManager = $entityManager;
  29.     }
  31.     public function hasPermission(string $action = null, ?\ReflectionMethod $method = null, ?Menu $menu = null): bool
  32.     {
  33.         if ($method)
  34.         {
  35.             return $this->hasPermissionByMethod($method);
  36.         }
  37.         elseif ($menu)
  38.         {
  39.             return $this->hasPermissionByMenu($action, $menu);
  40.         }
  41.         return false;
  42.     }
  44.     public function hasPermissionByRoute(string $route): bool
  45.     {
  46.         try {
  47.             if ($this->router->getRouteCollection()->get($route) === null)
  48.             {
  49.                 throw new \Exception(`The controller for route "${$route}" does not exist`);
  50.             }
  51.             return $this->hasPermissionByMethod(
  52.                 new \ReflectionMethod($this->router->getRouteCollection()->get($route)->getDefault('_controller'))
  53.             );
  54.         } catch (\ReflectionException $e) {
  55.             return true;
  56.         }
  57.     }
  59.     private function getMenuByRouteName(string $routeName)
  60.     {
  61.         return $this->entityManager->getRepository(Menu::class)->findOneBy([
  62.             'route' => $routeName
  63.         ]);
  64.     }
  66.     private function hasPermissionByMethod(\ReflectionMethod $method): bool
  67.     {
  68.         /** @var PermissionKey $permissionKey */
  69.         $permissionKey = $this->annotationReader->getClassAnnotation($method->getDeclaringClass(), PermissionKey::class);
  70.         /** @var HasPermission $needlePermission */
  71.         $needlePermission = $this->annotationReader->getMethodAnnotation($method, HasPermission::class);
  72.         if (!$permissionKey || !$needlePermission) {
  73.             // If the controller OR the action are not defined, access is granted
  74.             return true;
  75.         }
  76.         $menu = $this->entityManager->getRepository(Menu::class)->findOneBy(['route' => $this->annotationReader->getMethodAnnotation($method, Route::class)->getName()]);
  77.         if (!$menu) {
  78.             $menu = $this->entityManager->getRepository(Menu::class)->findOneBy(['permission_key' => $permissionKey->name]);
  79.         }
  81.         return $this->hasPermissionByMenu($needlePermission->action, $menu);
  82.     }
  84.     public function hasPermissionByMenu(string $action, Menu $menu): bool
  85.     {
  86.         $user = $this->security->getUser();
  87.         if (!$user instanceof User) {
  88.             return false;
  89.         }
  90.         $menuPermissions = !$menu->getPermissions()->isEmpty() ? $menu : $menu->getMenu() ?? $menu;
  92.         return (bool) $menuPermissions->getPermissions()->filter(
  93.             fn ($v) => $v->getProfile() === $user->getProfile()
  94.         )->first()->getActions()[$action];
  95.     }
  96. }