src/Twig/Runtime/AclRuntime.php line 122

Open in your IDE?
  1. <?php
  2. /** @noinspection ALL */
  4. namespace App\Twig\Runtime;
  6. use App\Constants\ACL;
  7. use App\Entity\Parameter;
  8. use App\Entity\SliderItem;
  9. use App\Entity\User;
  10. use App\Model\Product;
  11. use App\Services\Back\ParameterService;
  12. use App\Services\Common\AclServiceV2;
  13. use Doctrine\ORM\EntityManagerInterface;
  14. use Psr\Cache\InvalidArgumentException;
  15. use Symfony\Component\HttpFoundation\RequestStack;
  16. use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
  17. use Symfony\Component\Security\Core\Security;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Twig\Extension\RuntimeExtensionInterface;
  20. use Symfony\Component\Security\Core\Role\RoleHierarchyInterface;
  22. /**
  23. * Rassemble toute les fonction disponible dans twig qui touchent aux ACL et à l'affichage des données via les règles acl ou les systèmes paralèlles (roles, jobs sur les entités comme pour les slider ou les documents)
  24. */
  25. class AclRuntime implements RuntimeExtensionInterface
  26. {
  27. private AclServiceV2 $aclService;
  28. private RequestStack $requestStack;
  29. private ParameterService $parameterService;
  31. private Security $security;
  32. private RoleHierarchyInterface $roleHierarchy;
  33. private EntityManagerInterface $em;
  34. private array $userIsGrantedCache = [];
  35. private array $componentVisibilityCache = [];
  36. private array $displayConfigCache = [];
  37. private ?string $currentRouteCache = null;
  38. private mixed $currentRouteParamsCache = null;
  39. private bool $currentRequestResolved = false;
  40. private User|UserInterface|null $currentUserCache = null;
  41. private bool $currentUserResolved = false;
  44. public function __construct(
  45. AclServiceV2 $aclService,
  46. RequestStack $requestStack,
  47. ParameterService $parameterService,
  48. Security $security,
  49. RoleHierarchyInterface $roleHierarchy,
  50. EntityManagerInterface $em
  51. )
  52. {
  53. $this->aclService = $aclService;
  54. $this->requestStack = $requestStack;
  55. $this->parameterService = $parameterService;
  56. $this->security = $security;
  57. $this->roleHierarchy = $roleHierarchy;
  58. $this->em = $em;
  59. }
  61. /**
  62. * Permet de savoir si le user a le droit d'accéder à la route
  63. * @param User|null $user
  64. * @param string $route
  65. * @param array $params
  66. * @param string $env
  67. * @return bool
  68. */
  69. public function userIsGrantedRoute(
  70. ?User $user,
  71. string $route,
  72. array $params = [],
  73. string $env = ACL::FRONT_ENV,
  74. bool $debug = FALSE
  75. )
  76. {
  77. $config = [
  78. 'route' => $route,
  79. 'params' => $params,
  80. 'component' => ACL::ACL_NO_COMPONENT,
  81. 'slug' => ACL::ACL_NO_SLUG,
  82. 'action' => ACL::READ,
  83. 'env' => $env,
  84. ];
  86. return $this->aclService->userIsGranted( $user, $config, $debug );
  87. }
  89. /**
  90. * Permet de savoir si un user peut faire une action en fonction de son rôle ou de son job
  91. *
  92. * @param User|null $user
  93. * @param string $slug
  94. * @param string $action
  95. * @param string $env
  96. *
  97. * @return bool
  98. *
  99. * @throws InvalidArgumentException
  100. */
  101. public function userIsGranted(
  102. ?User $user,
  103. string $component,
  104. string $slug = ACL::ACL_NO_SLUG,
  105. string $action = ACL::READ,
  106. string $env = ACL::FRONT_ENV,
  107. string $route = NULL,
  108. string $params = NULL,
  109. bool $debug = FALSE
  110. ): bool
  111. {
  112. [$resolvedRoute, $resolvedParams] = $this->getCurrentRouteContext();
  113. $currentRoute = $route ?? $resolvedRoute;
  114. $currentParams = $params ?? $resolvedParams;
  116. if ($currentRoute === NULL){
  117. return $this->checkWhenRouteIsNull();
  118. }
  120. $config = [
  121. 'route' => $currentRoute,
  122. 'params' => $this->aclService->getRouteParamsForAcl($currentRoute, $currentParams),
  123. 'component' => $component,
  124. 'slug' => $slug,
  125. 'action' => $action,
  126. 'env' => $env,
  127. ];
  129. $cacheKey = implode('|', [
  130. $user instanceof User ? $user->getId() : 'anonymous',
  131. $currentRoute,
  132. $config['params'],
  133. $component,
  134. $slug,
  135. $action,
  136. $env,
  137. ]);
  139. if (array_key_exists($cacheKey, $this->userIsGrantedCache)) {
  140. return $this->userIsGrantedCache[$cacheKey];
  141. }
  143. return $this->userIsGrantedCache[$cacheKey] = $this->aclService->userIsGranted( $user, $config, $debug );
  144. }
  146. /**
  147. * Logique pour éviter des erreurs 500 si jamais une route est évaluée à NULL
  148. * Si on est dans le cas d'une exception on autorise la visualition
  149. * @return true
  150. * @throws \Exception
  151. */
  152. private function checkWhenRouteIsNull()
  153. {
  154. $request = $this->requestStack->getCurrentRequest();
  155. $exeption = $request->attributes->get('exception');
  157. if ($exeption !== null) {
  158. return TRUE;
  159. }
  161. throw new \Exception('Une erreur est survenue, la route ne peut pas être null et ne pas être une exception');
  162. }
  164. /**
  165. * Permet de savoir si le current user à le droit de voir le catalogue par son slug
  166. * @param $catalogue
  167. * @return bool
  168. * @throws InvalidArgumentException
  169. */
  170. public function userIsGrantedCatalogue($catalogue)
  171. {
  172. $currentUser = $this->security->getUser();
  173. return $this->aclService->userIsGrantedCatalogue($currentUser, $catalogue);
  174. }
  176. /**
  177. * Permet de savoir si le current user à le droit de voir le produit
  178. * @param Product $product
  179. *
  180. * @return bool
  181. * @throws \JsonException
  182. */
  183. public function userIsGrantedProduct(Product $product)
  184. {
  185. $currentUser = $this->security->getUser();
  186. return $this->aclService->userIsGrantedProduct($currentUser, $product);
  188. }
  190. /**
  191. * Retourne le slug du premier catalogue qui contient le produit et qui est accèssible au user courant
  192. * @param Product $product
  193. *
  194. * @return mixed|null
  195. * @throws \JsonException
  196. */
  197. public function getUserFirstGrantedCatalogSlugForProduct(Product $product)
  198. {
  199. $currentUser = $this->security->getUser();
  200. return $this->aclService->getUserFirstGrantedCatalogSlugForProduct($currentUser, $product);
  201. }
  204. /**
  205. * Défini si l'utilisateur à le droit de voir le document
  206. *
  207. * @param User|null $user
  208. * @param Parameter $document
  209. *
  210. * @return bool
  211. *
  212. * @throws \JsonException
  213. */
  214. public function canDisplayDocument( ?User $user, Parameter $document ): bool
  215. {
  216. return $this->aclService->userIsGrantedOnDocument( $user, $document );
  217. }
  219. public function filterVisibleDocuments(?User $user, array $documents, bool $onlyPublicOnSecurityRoute = false): array
  220. {
  221. [$currentRoute] = $this->getCurrentRouteContext();
  222. $isSecurityRoute = $currentRoute !== null && in_array($currentRoute, ACL::ACL_SECURITY_ROUTES, true);
  224. return array_values(array_filter($documents, function (Parameter $document) use ($user, $onlyPublicOnSecurityRoute, $isSecurityRoute) {
  225. if (!$this->canDisplayDocument($user, $document)) {
  226. return false;
  227. }
  229. if ($onlyPublicOnSecurityRoute && $isSecurityRoute && !$document->isPublic()) {
  230. return false;
  231. }
  233. return true;
  234. }));
  235. }
  238. /**
  239. * Lors des documents personnalisé, permet de savoit si le user peut voir le document
  240. *
  241. * @param User|null $user
  242. * @param $id
  243. *
  244. * @return bool
  245. *
  246. * @throws \JsonException
  247. */
  248. public function isDocumentSelectedForUser( ?User $user, $id ): bool
  249. {
  250. return $this->parameterService->isDocumentSelectedForUser( $user, $id );
  251. }
  254. /**
  255. * Permet de savoir si on component est visible par le user courant
  256. *
  257. * Ne doit être utilisé que pour l'affichage twig des components en front
  258. *
  259. * @param array|null $componentOptions
  260. * @param bool $debug
  261. * @return bool
  262. * @throws InvalidArgumentException
  263. */
  264. public function canDisplayComponentByAcl(?array $componentOptions, bool $debug = FALSE)
  265. {
  267. if ($componentOptions === NULL || $componentOptions === []){
  268. return TRUE;
  269. }
  271. [$currentRoute] = $this->getCurrentRouteContext();
  272. $currentUser = $this->getCurrentUser();
  274. $item = $componentOptions['item'] ?? $componentOptions;
  275. $display = $item['display'] ?? [];
  276. $univers = $item['univers'] ?? [];
  277. $componentAcl = $item['data']['data-component-acl'] ?? ACL::ACL_NO_COMPONENT;
  278. $cacheKey = implode('|', [
  279. $currentRoute ?? 'no-route',
  280. $currentUser instanceof User ? $currentUser->getId() : 'anonymous',
  281. $componentAcl,
  282. (int)($item['enabled'] ?? true),
  283. md5(json_encode($display)),
  284. md5(json_encode($univers)),
  285. ]);
  287. if (array_key_exists($cacheKey, $this->componentVisibilityCache)) {
  288. return $this->componentVisibilityCache[$cacheKey];
  289. }
  291. // Le component est actif sur la page ?
  292. $canDisplay = (bool)$item[ 'enabled' ] ?? TRUE;
  293. if (!$canDisplay) {
  294. return $this->componentVisibilityCache[$cacheKey] = FALSE;
  295. }
  297. // on regarde s'il peut s'afficher sur la page via la clef display
  298. $canDisplay = $this->canDisplayOnPageByConfig($display, $debug);
  299. if (!$canDisplay) {
  300. return $this->componentVisibilityCache[$cacheKey] = FALSE;
  301. }
  303. // on recherche l'acl si on peut récupérer son slug data-component-acl
  304. if (isset($item['data']['data-component-acl'])){
  305. $canDisplay = $this->userIsGranted($currentUser instanceof User ? $currentUser : null, $componentAcl);
  306. }
  307. if (!$canDisplay) {
  308. return $this->componentVisibilityCache[$cacheKey] = FALSE;
  309. }
  311. // on regarde s'il y a des univers... on verifie le currentUser car le component peut être utilisé en partie security
  312. if ($currentUser instanceof User && $univers !== []){
  313. if ( $canDisplay && !$currentUser->isDeveloper() && !$currentUser->isSuperAdmin()){
  314. $canDisplay = $this->aclService->canDisplayByUniverses($currentUser, $univers);
  315. }
  316. }
  318. return $this->componentVisibilityCache[$cacheKey] = $canDisplay;
  320. }
  322. /**
  323. * Défini si un component s'affiche via la clef display
  324. *
  325. * Elle contient 2 enfants:
  326. * enabled_on : array (tableau de route)|null
  327. * disabled_on : array (tableau de route)|null
  328. * Si disabled_on est a autre chose que null, alors c'est lui qui prend l'ascendant
  329. * Afficher partout => enabled_on: null + disabled_on: [] ou null
  330. *
  331. * @param array $display
  332. *
  333. * @return bool
  334. */
  335. private function canDisplayOnPageByConfig(array $display, bool $debug = FALSE)
  336. {
  337. [$currentRoute] = $this->getCurrentRouteContext();
  339. if ($currentRoute === NULL){
  340. return $this->checkWhenRouteIsNull();
  341. }
  343. $cacheKey = md5(json_encode([$currentRoute, $display]));
  344. if (array_key_exists($cacheKey, $this->displayConfigCache)) {
  345. return $this->displayConfigCache[$cacheKey];
  346. }
  348. $canDisplay = TRUE; // par défaut on affiche
  350. // On prend la config du disabled_on si elle n'est pas nulle
  351. $displayByDisabled = FALSE;
  352. if (isset($display['disabled_on']) && $display['disabled_on'] !== NULL){
  353. $displayByDisabled = TRUE;
  354. }
  356. // On prend la config enbaled_on
  357. if (isset($display['enabled_on']) && !$displayByDisabled){
  359. $arrayRoute = $display['enabled_on'];
  361. if(gettype($display['enabled_on']) === "string") {
  362. $arrayRoute = json_decode($display['enabled_on'], true);
  363. }
  365. switch (TRUE){
  366. // tableau vide, ce n'est pas visible
  367. case $arrayRoute === []:
  368. $canDisplay = FALSE;
  369. break;
  370. // NULL ou valeur qui n'est pas un tableau, on considère que c'est visible
  371. // ainsi si enabled_on et disabled_on sont NULL, on affiche
  372. case $arrayRoute === NULL:
  373. case !is_array($arrayRoute):
  374. $canDisplay = TRUE;
  375. break;
  376. // on regarde si la route actuelle est dans le tableau pour l'afficher
  377. default:
  378. $canDisplay = in_array( $currentRoute, $arrayRoute, TRUE );
  379. break;
  380. }
  381. }
  383. // on prend la config disabled_on
  384. if (isset($display['disabled_on']) && $displayByDisabled){
  386. $arrayRoute = $display['disabled_on'];
  388. if(gettype($display['disabled_on']) === "string") {
  389. $arrayRoute = json_decode($display['disabled_on'], true);
  390. }
  392. switch (TRUE){
  393. // tableau vide, c'est visible partout
  394. case $arrayRoute === []:
  395. $canDisplay = TRUE;
  396. break;
  397. // NULL ou valeur qui n'est pas un tableau, on refuse l'affichage
  398. // Normalement on ne tombe pas dans cette configuration puisque $displayByDisabled est FALSE
  399. case $arrayRoute === NULL:
  400. case !is_array($arrayRoute):
  401. $canDisplay = FALSE;
  402. break;
  403. // on regarde si la route actuelle est dans le tableau pour refuser l'affichage
  404. default:
  405. $canDisplay = !in_array( $currentRoute, $arrayRoute, TRUE );
  406. break;
  407. }
  408. }
  410. return $this->displayConfigCache[$cacheKey] = $canDisplay;
  411. }
  413. private function getCurrentRouteContext(): array
  414. {
  415. if ($this->currentRequestResolved) {
  416. return [$this->currentRouteCache, $this->currentRouteParamsCache];
  417. }
  419. $request = $this->requestStack->getCurrentRequest();
  420. $this->currentRouteCache = $request?->get('_route');
  421. $this->currentRouteParamsCache = $request?->get('_route_params');
  422. $this->currentRequestResolved = true;
  424. return [$this->currentRouteCache, $this->currentRouteParamsCache];
  425. }
  427. private function getCurrentUser(): User|UserInterface|null
  428. {
  429. if ($this->currentUserResolved) {
  430. return $this->currentUserCache;
  431. }
  433. $this->currentUserCache = $this->security->getUser();
  434. $this->currentUserResolved = true;
  436. return $this->currentUserCache;
  437. }
  440. /**
  441. * Permet de savoir si le user peut voir le slider
  442. *
  443. * Les acl du slider sont intégré à l'édition de l'entité
  444. *
  445. * @param User $user
  446. * @param SliderItem $item
  447. *
  448. * @return bool
  449. */
  450. public function canDisplaySliderItem(?User $user, SliderItem $item): bool
  451. {
  452. if(!$user) return FALSE;
  454. $jobs = $item->getDisplayJob();
  455. $universes = $item->getDisplayUniverses();
  458. // Le superadmin et dev doivent pouvoir tout voir...
  459. if ( $user->isDeveloper() || $user->isSuperAdmin() ) {
  460. return TRUE;
  461. }
  463. // Par défaut, tout s'affiche
  464. $canDisplay = TRUE;
  466. // SI config par job on regarde si ça match
  467. if ( $jobs !== NULL && !in_array( $user->getJob(), $jobs, TRUE ) ) {
  468. $canDisplay = FALSE;
  469. }
  471. // Si config par univers on regarde si ça match
  472. if ( $universes !== NULL ) {
  473. foreach ( $user->getUniverses() as $userUnivers ) {
  474. if ( in_array( $userUnivers->getSlug(), $universes, TRUE ) ) {
  475. $canDisplay = TRUE;
  476. break;
  477. }
  478. $canDisplay = FALSE;
  479. }
  480. }
  482. return $canDisplay;
  484. }
  486. /**
  487. * Normalise la transformation de l'array qui contient les params d'une route pour la transformer en string
  488. * @param array $params
  489. *
  490. * @return false|string
  491. * @throws \JsonException
  492. */
  493. public function formatParamsToString(array $params)
  494. {
  495. return $this->aclService->formatArrayParamsToString($params);
  496. }
  499. /**
  500. * Retourne un tableau avec la liste de roles et les jobs relatif à ces roles
  501. *
  502. * @return array[]
  503. */
  504. public function getDefaultRolesAndJobs()
  505. {
  506. return $this->aclService->getDefaultRoleAndJob();
  507. }
  510. /**
  511. * @return UserInterface|null
  512. */
  513. public function getOriginalUser(): ?UserInterface
  514. {
  515. $token = $this->security->getToken();
  517. if ($token instanceof SwitchUserToken)
  518. {
  519. $user = $token->getOriginalToken()->getUser();
  520. $user = $this->em->getRepository(User::class)->findOneBy(['email' => $user->getEmail()]);
  521. return $user;
  522. }
  524. return $this->security->getUser();
  525. }
  528. /**
  529. * @param User $user
  530. * @param string $role
  531. *
  532. * @return bool
  533. */
  534. public function hasRole(User $user, string $role): bool
  535. {
  536. $reachableRoles = $this->roleHierarchy->getReachableRoleNames($user->getRoles());
  537. return in_array($role, $reachableRoles);
  538. }
  540. }