src/Twig/Runtime/AclRuntime.php line 240

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 = [];
  39. public function __construct(
  40. AclServiceV2 $aclService,
  41. RequestStack $requestStack,
  42. ParameterService $parameterService,
  43. Security $security,
  44. RoleHierarchyInterface $roleHierarchy,
  45. EntityManagerInterface $em
  46. )
  47. {
  48. $this->aclService = $aclService;
  49. $this->requestStack = $requestStack;
  50. $this->parameterService = $parameterService;
  51. $this->security = $security;
  52. $this->roleHierarchy = $roleHierarchy;
  53. $this->em = $em;
  54. }
  56. /**
  57. * Permet de savoir si le user a le droit d'accéder à la route
  58. * @param User|null $user
  59. * @param string $route
  60. * @param array $params
  61. * @param string $env
  62. * @return bool
  63. */
  64. public function userIsGrantedRoute(
  65. ?User $user,
  66. string $route,
  67. array $params = [],
  68. string $env = ACL::FRONT_ENV,
  69. bool $debug = FALSE
  70. )
  71. {
  72. $config = [
  73. 'route' => $route,
  74. 'params' => $params,
  75. 'component' => ACL::ACL_NO_COMPONENT,
  76. 'slug' => ACL::ACL_NO_SLUG,
  77. 'action' => ACL::READ,
  78. 'env' => $env,
  79. ];
  81. return $this->aclService->userIsGranted( $user, $config, $debug );
  82. }
  84. /**
  85. * Permet de savoir si un user peut faire une action en fonction de son rôle ou de son job
  86. *
  87. * @param User|null $user
  88. * @param string $slug
  89. * @param string $action
  90. * @param string $env
  91. *
  92. * @return bool
  93. *
  94. * @throws InvalidArgumentException
  95. */
  96. public function userIsGranted(
  97. ?User $user,
  98. string $component,
  99. string $slug = ACL::ACL_NO_SLUG,
  100. string $action = ACL::READ,
  101. string $env = ACL::FRONT_ENV,
  102. string $route = NULL,
  103. string $params = NULL,
  104. bool $debug = FALSE
  105. ): bool
  106. {
  107. $currentRoute = $route ?? $this->requestStack->getCurrentRequest()->get( '_route' );
  108. $currentParams = $params ?? $this->requestStack->getCurrentRequest()->get( '_route_params' );
  110. if ($currentRoute === NULL){
  111. return $this->checkWhenRouteIsNull();
  112. }
  114. $config = [
  115. 'route' => $currentRoute,
  116. 'params' => $this->aclService->getRouteParamsForAcl($currentRoute, $currentParams),
  117. 'component' => $component,
  118. 'slug' => $slug,
  119. 'action' => $action,
  120. 'env' => $env,
  121. ];
  123. $cacheKey = implode('|', [
  124. $user instanceof User ? $user->getId() : 'anonymous',
  125. $currentRoute,
  126. $config['params'],
  127. $component,
  128. $slug,
  129. $action,
  130. $env,
  131. ]);
  133. if (array_key_exists($cacheKey, $this->userIsGrantedCache)) {
  134. return $this->userIsGrantedCache[$cacheKey];
  135. }
  137. return $this->userIsGrantedCache[$cacheKey] = $this->aclService->userIsGranted( $user, $config, $debug );
  138. }
  140. /**
  141. * Logique pour éviter des erreurs 500 si jamais une route est évaluée à NULL
  142. * Si on est dans le cas d'une exception on autorise la visualition
  143. * @return true
  144. * @throws \Exception
  145. */
  146. private function checkWhenRouteIsNull()
  147. {
  148. $request = $this->requestStack->getCurrentRequest();
  149. $exeption = $request->attributes->get('exception');
  151. if ($exeption !== null) {
  152. return TRUE;
  153. }
  155. throw new \Exception('Une erreur est survenue, la route ne peut pas être null et ne pas être une exception');
  156. }
  158. /**
  159. * Permet de savoir si le current user à le droit de voir le catalogue par son slug
  160. * @param $catalogue
  161. * @return bool
  162. * @throws InvalidArgumentException
  163. */
  164. public function userIsGrantedCatalogue($catalogue)
  165. {
  166. $currentUser = $this->security->getUser();
  167. return $this->aclService->userIsGrantedCatalogue($currentUser, $catalogue);
  168. }
  170. /**
  171. * Permet de savoir si le current user à le droit de voir le produit
  172. * @param Product $product
  173. *
  174. * @return bool
  175. * @throws \JsonException
  176. */
  177. public function userIsGrantedProduct(Product $product)
  178. {
  179. $currentUser = $this->security->getUser();
  180. return $this->aclService->userIsGrantedProduct($currentUser, $product);
  182. }
  184. /**
  185. * Retourne le slug du premier catalogue qui contient le produit et qui est accèssible au user courant
  186. * @param Product $product
  187. *
  188. * @return mixed|null
  189. * @throws \JsonException
  190. */
  191. public function getUserFirstGrantedCatalogSlugForProduct(Product $product)
  192. {
  193. $currentUser = $this->security->getUser();
  194. return $this->aclService->getUserFirstGrantedCatalogSlugForProduct($currentUser, $product);
  195. }
  198. /**
  199. * Défini si l'utilisateur à le droit de voir le document
  200. *
  201. * @param User|null $user
  202. * @param Parameter $document
  203. *
  204. * @return bool
  205. *
  206. * @throws \JsonException
  207. */
  208. public function canDisplayDocument( ?User $user, Parameter $document ): bool
  209. {
  210. return $this->aclService->userIsGrantedOnDocument( $user, $document );
  211. }
  214. /**
  215. * Lors des documents personnalisé, permet de savoit si le user peut voir le document
  216. *
  217. * @param User|null $user
  218. * @param $id
  219. *
  220. * @return bool
  221. *
  222. * @throws \JsonException
  223. */
  224. public function isDocumentSelectedForUser( ?User $user, $id ): bool
  225. {
  226. return $this->parameterService->isDocumentSelectedForUser( $user, $id );
  227. }
  230. /**
  231. * Permet de savoir si on component est visible par le user courant
  232. *
  233. * Ne doit être utilisé que pour l'affichage twig des components en front
  234. *
  235. * @param array|null $componentOptions
  236. * @param bool $debug
  237. * @return bool
  238. * @throws InvalidArgumentException
  239. */
  240. public function canDisplayComponentByAcl(?array $componentOptions, bool $debug = FALSE)
  241. {
  243. if ($componentOptions === NULL || $componentOptions === []){
  244. return TRUE;
  245. }
  247. $request = $this->requestStack->getCurrentRequest();
  248. $cacheKey = md5(json_encode([
  249. 'route' => $request?->get('_route'),
  250. 'user' => $this->security->getUser() instanceof User ? $this->security->getUser()->getId() : 'anonymous',
  251. 'componentOptions' => $componentOptions,
  252. ]));
  254. if (array_key_exists($cacheKey, $this->componentVisibilityCache)) {
  255. return $this->componentVisibilityCache[$cacheKey];
  256. }
  258. $item = $componentOptions['item'] ?? $componentOptions;
  260. // Le component est actif sur la page ?
  261. $canDisplay = (bool)$item[ 'enabled' ] ?? TRUE;
  262. if (!$canDisplay) {
  263. return FALSE;
  264. }
  266. // on regarde s'il peut s'afficher sur la page via la clef display
  267. $canDisplay = $this->canDisplayOnPageByConfig($item['display'], $debug);
  268. if (!$canDisplay) {
  269. return FALSE;
  270. }
  272. /** @var User $currentUser */
  273. $currentUser = $this->security->getUser();
  275. // on recherche l'acl si on peut récupérer son slug data-component-acl
  276. if ( isset($item['data']['data-component-acl'])){
  277. $canDisplay = $this->userIsGranted($currentUser, $item['data']['data-component-acl'] ?? ACL::ACL_NO_COMPONENT);
  278. }
  279. if (!$canDisplay) {
  280. return FALSE;
  281. }
  283. // on regarde s'il y a des univers... on verifie le currentUser car le component peut être utilisé en partie security
  284. if ($currentUser !== NULL && isset($item['univers'])){
  285. if ( $canDisplay && !$currentUser->isDeveloper() && !$currentUser->isSuperAdmin() && isset($item['univers'])){
  286. $canDisplay = $this->aclService->canDisplayByUniverses($currentUser, $item['univers']);
  287. }
  288. }
  290. return $this->componentVisibilityCache[$cacheKey] = $canDisplay;
  292. }
  294. /**
  295. * Défini si un component s'affiche via la clef display
  296. *
  297. * Elle contient 2 enfants:
  298. * enabled_on : array (tableau de route)|null
  299. * disabled_on : array (tableau de route)|null
  300. * Si disabled_on est a autre chose que null, alors c'est lui qui prend l'ascendant
  301. * Afficher partout => enabled_on: null + disabled_on: [] ou null
  302. *
  303. * @param array $display
  304. *
  305. * @return bool
  306. */
  307. private function canDisplayOnPageByConfig(array $display, bool $debug = FALSE)
  308. {
  310. $currentRoute = $this->requestStack->getCurrentRequest()->get( '_route' );
  312. if ($currentRoute === NULL){
  313. return $this->checkWhenRouteIsNull();
  314. }
  316. $cacheKey = md5(json_encode([$currentRoute, $display]));
  317. if (array_key_exists($cacheKey, $this->displayConfigCache)) {
  318. return $this->displayConfigCache[$cacheKey];
  319. }
  321. $canDisplay = TRUE; // par défaut on affiche
  323. // On prend la config du disabled_on si elle n'est pas nulle
  324. $displayByDisabled = FALSE;
  325. if (isset($display['disabled_on']) && $display['disabled_on'] !== NULL){
  326. $displayByDisabled = TRUE;
  327. }
  329. // On prend la config enbaled_on
  330. if (isset($display['enabled_on']) && !$displayByDisabled){
  332. $arrayRoute = $display['enabled_on'];
  334. if(gettype($display['enabled_on']) === "string") {
  335. $arrayRoute = json_decode($display['enabled_on'], true);
  336. }
  338. switch (TRUE){
  339. // tableau vide, ce n'est pas visible
  340. case $arrayRoute === []:
  341. $canDisplay = FALSE;
  342. break;
  343. // NULL ou valeur qui n'est pas un tableau, on considère que c'est visible
  344. // ainsi si enabled_on et disabled_on sont NULL, on affiche
  345. case $arrayRoute === NULL:
  346. case !is_array($arrayRoute):
  347. $canDisplay = TRUE;
  348. break;
  349. // on regarde si la route actuelle est dans le tableau pour l'afficher
  350. default:
  351. $canDisplay = in_array( $currentRoute, $arrayRoute, TRUE );
  352. break;
  353. }
  354. }
  356. // on prend la config disabled_on
  357. if (isset($display['disabled_on']) && $displayByDisabled){
  359. $arrayRoute = $display['disabled_on'];
  361. if(gettype($display['disabled_on']) === "string") {
  362. $arrayRoute = json_decode($display['disabled_on'], true);
  363. }
  365. switch (TRUE){
  366. // tableau vide, c'est visible partout
  367. case $arrayRoute === []:
  368. $canDisplay = TRUE;
  369. break;
  370. // NULL ou valeur qui n'est pas un tableau, on refuse l'affichage
  371. // Normalement on ne tombe pas dans cette configuration puisque $displayByDisabled est FALSE
  372. case $arrayRoute === NULL:
  373. case !is_array($arrayRoute):
  374. $canDisplay = FALSE;
  375. break;
  376. // on regarde si la route actuelle est dans le tableau pour refuser l'affichage
  377. default:
  378. $canDisplay = !in_array( $currentRoute, $arrayRoute, TRUE );
  379. break;
  380. }
  381. }
  383. return $this->displayConfigCache[$cacheKey] = $canDisplay;
  384. }
  387. /**
  388. * Permet de savoir si le user peut voir le slider
  389. *
  390. * Les acl du slider sont intégré à l'édition de l'entité
  391. *
  392. * @param User $user
  393. * @param SliderItem $item
  394. *
  395. * @return bool
  396. */
  397. public function canDisplaySliderItem(?User $user, SliderItem $item): bool
  398. {
  399. if(!$user) return FALSE;
  401. $jobs = $item->getDisplayJob();
  402. $universes = $item->getDisplayUniverses();
  405. // Le superadmin et dev doivent pouvoir tout voir...
  406. if ( $user->isDeveloper() || $user->isSuperAdmin() ) {
  407. return TRUE;
  408. }
  410. // Par défaut, tout s'affiche
  411. $canDisplay = TRUE;
  413. // SI config par job on regarde si ça match
  414. if ( $jobs !== NULL && !in_array( $user->getJob(), $jobs, TRUE ) ) {
  415. $canDisplay = FALSE;
  416. }
  418. // Si config par univers on regarde si ça match
  419. if ( $universes !== NULL ) {
  420. foreach ( $user->getUniverses() as $userUnivers ) {
  421. if ( in_array( $userUnivers->getSlug(), $universes, TRUE ) ) {
  422. $canDisplay = TRUE;
  423. break;
  424. }
  425. $canDisplay = FALSE;
  426. }
  427. }
  429. return $canDisplay;
  431. }
  433. /**
  434. * Normalise la transformation de l'array qui contient les params d'une route pour la transformer en string
  435. * @param array $params
  436. *
  437. * @return false|string
  438. * @throws \JsonException
  439. */
  440. public function formatParamsToString(array $params)
  441. {
  442. return $this->aclService->formatArrayParamsToString($params);
  443. }
  446. /**
  447. * Retourne un tableau avec la liste de roles et les jobs relatif à ces roles
  448. *
  449. * @return array[]
  450. */
  451. public function getDefaultRolesAndJobs()
  452. {
  453. return $this->aclService->getDefaultRoleAndJob();
  454. }
  457. /**
  458. * @return UserInterface|null
  459. */
  460. public function getOriginalUser(): ?UserInterface
  461. {
  462. $token = $this->security->getToken();
  464. if ($token instanceof SwitchUserToken)
  465. {
  466. $user = $token->getOriginalToken()->getUser();
  467. $user = $this->em->getRepository(User::class)->findOneBy(['email' => $user->getEmail()]);
  468. return $user;
  469. }
  471. return $this->security->getUser();
  472. }
  475. /**
  476. * @param User $user
  477. * @param string $role
  478. *
  479. * @return bool
  480. */
  481. public function hasRole(User $user, string $role): bool
  482. {
  483. $reachableRoles = $this->roleHierarchy->getReachableRoleNames($user->getRoles());
  484. return in_array($role, $reachableRoles);
  485. }
  487. }