src/Twig/Runtime/PlatformComponentRuntime.php line 441

Open in your IDE?
  1. <?php
  3. namespace App\Twig\Runtime;
  5. use App\Entity\User;
  6. use App\Services\Back\Settings\FrontService;
  7. use Exception;
  8. use JsonException;
  9. use Psr\Log\LoggerInterface;
  10. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  11. use Symfony\Component\HttpKernel\KernelInterface;
  12. use Symfony\Component\Security\Core\Security;
  13. use Twig\Environment;
  14. use Twig\Error\LoaderError;
  15. use Twig\Error\RuntimeError;
  16. use Twig\Error\SyntaxError;
  17. use Twig\Extension\RuntimeExtensionInterface;
  19. class PlatformComponentRuntime implements RuntimeExtensionInterface
  20. {
  21. private ParameterBagInterface $params;
  22. private Environment $twig;
  23. private Security $security;
  24. private LoggerInterface $logger;
  25. private FrontService $frontService;
  26. private KernelInterface $kernel;
  27. private string $projectDir;
  28. private array $contentDataCache = [];
  29. private array $componentOptionsCache = [];
  32. /**
  33. * @param ParameterBagInterface $params
  34. * @param Environment $twig
  35. * @param Security $security
  36. * @param LoggerInterface $logger
  37. * @param FrontService $frontService
  38. * @param KernelInterface $kernel
  39. * @param string $projectDir
  40. */
  41. public function __construct(
  42. ParameterBagInterface $params,
  43. Environment $twig,
  44. Security $security,
  45. LoggerInterface $logger,
  46. FrontService $frontService,
  47. KernelInterface $kernel,
  48. string $projectDir
  49. ) {
  50. $this->params = $params;
  51. $this->twig = $twig;
  52. $this->security = $security;
  53. $this->logger = $logger;
  54. $this->frontService = $frontService;
  55. $this->projectDir = $projectDir;
  56. $this->kernel = $kernel;
  57. }
  59. /**
  60. * Retourne le contenu d'un component
  61. *
  62. * @TODO Attention,si on passe le $component comme un tableau avec les valeurs du yaml !
  63. * On ne peut pas utiliser le système d'ACL dynamique
  64. *
  65. * @param string|array $component
  66. * @param string $componentKey
  67. * @param null $data
  68. * @param null $index
  69. * @param bool $debug
  70. *
  71. * @return string
  72. *
  73. * @throws JsonException
  74. */
  75. public function component($component, string $componentKey = '', $data = NULL, $index = NULL, bool $debug = FALSE): string
  76. {
  77. $keys = $componentKey;
  79. if (is_array($component) && isset($component[ 'type' ])) {
  80. $value = $component;
  81. } else {
  82. $keyArr = explode('.', $keys);
  83. if (count($keyArr) === 2) {
  84. $data = $this->getContentData($keyArr[ 1 ], $keyArr[ 0 ]);
  85. $value = $data[ 'pageArray' ];
  86. } else {
  87. $value = $this->checkComponent($component, $keys, $index);
  88. }
  89. }
  91. if (!isset($value[ 'type' ])) {
  92. return '<div class="text-danger">The component ' . $component . ' is typeless!</div>';
  93. }
  94. // try {
  95. return $this->buildComponent($value, $keys, $data, $debug);
  96. // }
  97. // catch (LoaderError|RuntimeError|SyntaxError $e)
  98. // {
  99. // if($this->kernel->getEnvironment() == 'dev') throw $e;
  100. //
  101. // $message = 'Le component ' . (is_array($keys) ? implode('.', $keys) : $value[ 'type' ]) . ' ne peut pas être généré.';
  102. // $this->logger->critical($message . $e->getMessage());
  103. //
  104. // $error = '<div class="text-danger">' . $message;
  105. // /** @var User $currentUser */
  106. // $currentUser = $this->security->getUser();
  107. //
  108. // if (($currentUser !== NULL && $currentUser->isDeveloper()) || $this->kernel->getEnvironment() === 'dev') {
  109. // $error .= '<pre>' . $e->getMessage() . '</pre>';
  110. // }
  111. // $error .= '</div>';
  112. // return $error;
  113. // }
  114. }
  116. /**
  117. * @param string $page
  118. * @param $data
  119. * @param bool $isSecurity
  120. *
  121. * @return string
  122. *
  123. * @throws JsonException
  124. */
  125. public function content(string $page, $data = NULL, bool $isSecurity = FALSE, string $key = null): string
  126. {
  127. $frontType = $isSecurity ? 'security' : 'content';
  128. $contentData = $this->getContentData($page, $frontType);
  129. $pageArray = $contentData[ 'pageArray' ] ?? [];
  130. $frontCat = $contentData[ 'frontCat' ];
  132. $divs = $this->getContentStartDivs($pageArray);
  133. $content = '';
  135. if($key) {
  136. $content .= $this->component($pageArray[$key], $contentData[ 'contentKey' ] . '.sections.' . $key, $data, NULL, TRUE);
  137. return implode('', $divs) . $content . str_repeat('</div>', count($divs));
  138. }
  140. $items = $pageArray[ 'sections' ];
  142. foreach ($items as $key => $item)
  143. {
  144. // try {
  145. $content .= $this->component($item, $contentData[ 'contentKey' ] . '.sections.' . $key, $data, NULL, TRUE);
  146. // $content .= $this->component( $frontCat . '.' . $page . '.sections.' . $key, $data );
  147. // } catch (Exception $e) {
  148. // /** @var User $currentUser */
  149. // $currentUser = $this->security->getUser();
  150. // if ($currentUser !== NULL && $currentUser->isDeveloper()) {
  151. // echo '<div style="border: 1px red solid; padding:8px; color:red; text-align:center">' .
  152. // '<strong>' . $frontCat . '.' . $page . '.sections.' . $key . '</strong><br>' .
  153. // $e->getMessage() .
  154. // '</div>';
  155. // }
  156. // }
  157. }
  159. return implode('', $divs) . $content . str_repeat('</div>', count($divs));
  160. }
  162. /**
  163. * @param $item
  164. *
  165. * @return array
  166. */
  167. public function getItemData($item): array
  168. {
  169. $result = [];
  170. if (isset($item[ 'data' ]) && count($item[ 'data' ]) > 0) {
  171. foreach ($item[ 'data' ] as $k => $v) {
  172. $result[ 'data-' . str_replace('_', '-', $k) ] = $v;
  173. }
  174. }
  175. return $result;
  176. }
  178. /**
  179. * Retourne le tableau permettant la génération dynamique d'un élément en twig (wrapper, item, container)
  180. *
  181. * Les components doivent être configuré avec les éléments suivants :
  182. *
  183. * mon_component:
  184. * type: mon_type_de_component
  185. * wrapper: <== va gérer une div qui engloble le component
  186. * class: ""
  187. * class: "" <== va gérer la class du component
  188. * container: <== va gérer une div interne au component qui va contenir les sous-éléments du component
  189. * class: ""
  190. *
  191. * <div class="ma-classe-wrapper" + autres éléments dans wrapper>
  192. * <div class="ma-classe" + autres élément>
  193. * <div class="ma-classe-container" + autres éléments dans container>
  194. *
  195. * Cette configuration permet une plus grande souplesse pour organiser les éléments via les class bootstrap
  196. *
  197. * @param array|string $item tableau contenant les données de l'élément, si c'est une string, c'est pour maintenir l'ancien système
  198. * @param string $key clé du data-component-acl pour son identification
  199. * @param bool $debug
  200. *
  201. * @return array tableau contenant les informations
  202. *
  203. * id => si le component doit avoir un id, '' par défaut
  204. * class => class de l'élément, '' par défaut
  205. * data => tableau qui contient tous les éléments data de l'élément et leur valeur (data-foo="bla"), [] par défaut
  206. * tag => le tag de l'élément si c'est précisé, div par défaut
  207. * style => tableau si des éléments doivent être passé dans style (style="background:red"), défaut []
  208. * enabled => Bool pour savoir si l'élément s'affiche ou non, défaut TRUE
  209. * display => tableau qui gère l'affichage par addition ou soustraction sur des pages, défaut []
  210. * univers => uniquement si des datas sont passée dans l'item
  211. */
  212. public function generateDomOption($item, string $key = '', bool $debug = false): array
  213. {
  214. $result = [
  215. 'id' => '',
  216. 'data' => [],
  217. 'tag' => 'div',
  218. 'style' => [],
  219. 'enabled' => true,
  220. 'display' => []
  221. ];
  223. // $item n'est pas un array (ancien système → wrapper correspond à la class)
  224. if (!is_array($item)) {
  225. $result[ 'class' ] = $item;
  226. return $result;
  227. }
  229. $result[ 'class' ] = $this->getClassForItem($item);
  230. $result[ 'id' ] = $item[ 'id' ] ?? $result[ 'id' ];
  231. $result[ 'tag' ] = $item[ 'tag' ] ?? $result[ 'tag' ];
  233. if (isset($item[ 'data' ]) && $item[ 'data' ] !== []) {
  234. $result[ 'data' ] = $this->getItemData($item);
  235. }
  237. if ($key !== '') {
  238. $result[ 'data' ][ 'data-component-acl' ] = $key;
  239. $result[ 'enabled' ] = $item[ 'enabled' ] ?? TRUE;
  240. $result[ 'display' ] = $item[ 'display' ] ?? [];
  242. if (isset($item[ 'univers' ]) && $item[ 'univers' ] !== []) {
  243. $result[ 'univers' ] = $item[ 'univers' ];
  244. }
  245. }
  247. if (isset($item[ 'style' ]) && $item[ 'style' ] !== []) {
  248. foreach ($item[ 'style' ] as $rule => $value) {
  249. $result[ 'style' ][ str_replace('_', '-', $rule) ] = $value;
  250. }
  251. }
  252. return $result;
  253. }
  255. /**
  256. * Génère le tableau permettant la création dynamique d'un atom dans le twig
  257. *
  258. * Pour un atom, c'est la clef wrapper qui va prendre le data-acl-component
  259. *
  260. * @param array|null $atom tableau contenant les data de l'atom TODO gerer un toArray si on passe un objet
  261. * @param string|null $key clé identifiant l'atom pour les ACL
  262. * @param bool $debug
  263. *
  264. * @return array
  265. */
  266. public function generateAtomOptions(?array $atom, ?string $key = '', bool $debug = FALSE): array
  267. {
  268. // wrapper n'existe pas, ou est null, ou n'est pas un tableau
  269. switch (TRUE) {
  270. case !isset($atom[ 'wrapper' ]):
  271. $wrapper = [];
  272. break;
  273. case is_string($atom[ 'wrapper' ]):
  274. $wrapper = [
  275. 'class' => $atom[ 'wrapper' ],
  276. ];
  277. break;
  278. default:
  279. $wrapper = $atom[ 'wrapper' ];
  280. break;
  281. }
  283. $result = array_merge(
  284. [
  285. 'enabled' => $atom[ 'enabled' ] ?? TRUE,
  286. ],
  287. $wrapper,
  288. );
  289. return $this->generateDomOption($result, $key);
  290. }
  292. /**
  293. * @param $component
  294. * @param string|null $key
  295. *
  296. * @return array
  297. */
  298. public function generateComponentOptions($component, ?string $key = '', $debug = false): array
  299. {
  300. $cacheKey = md5(json_encode([$key, $component]));
  301. if (array_key_exists($cacheKey, $this->componentOptionsCache)) {
  302. return $this->componentOptionsCache[$cacheKey];
  303. }
  305. $key = $key ?? '';
  306. // WRAPPER
  307. $wrapperKey = 'wrapper';
  308. $wrapper = isset($component[ $wrapperKey ]) ? $this->generateDomOption($component[ $wrapperKey ], '', $debug) : $this->generateDomOption([], '', $debug);
  309. // ITEM
  310. $item = $this->generateDomOption($component, $key, $debug);
  311. // CONTAINER
  312. $containerKey = 'container';
  313. $container = isset($component[ $containerKey ]) ? $this->generateDomOption($component[ $containerKey ], '', $debug) : $this->generateDomOption([], '', $debug);
  315. return $this->componentOptionsCache[$cacheKey] = [
  316. 'wrapper' => $wrapper,
  317. 'item' => $item,
  318. 'container' => $container,
  319. ];
  320. }
  322. /**
  323. * @param string $keys
  324. * @param array|null $platform
  325. * @param string|null $lastKeyPlatform
  326. *
  327. * @return array|mixed
  328. *
  329. * @throws JsonException
  330. */
  331. public function getFrontDataFromSettingOrYaml(string $keys, ?array $platform, ?string $lastKeyPlatform = NULL)
  332. {
  333. return $this->frontService->getFrontDataFromSettingOrYaml($keys, $platform, $lastKeyPlatform);
  334. }
  336. /**
  337. * TODO Vérifier son utilisation, pour le moment uniquement sur default_progression_status_step.html.twig
  338. *
  339. * @param $atomic_component
  340. *
  341. * @return string
  342. *
  343. * @throws LoaderError
  344. * @throws RuntimeError
  345. * @throws SyntaxError
  346. */
  347. public function customAtomicContent($atomic_component): string
  348. {
  349. $folder = '/templates/platform/component';
  351. if (file_exists($this->projectDir . $folder . '/atom/' . $atomic_component . '.html.twig')) {
  352. $view = 'platform/component/atom/' . $atomic_component . '.html.twig';
  353. } elseif (file_exists($this->projectDir . $folder . '/molecule/' . $atomic_component . '.html.twig')) {
  354. $view = 'platform/component/molecule/' . $atomic_component . '.html.twig';
  355. } elseif (file_exists($this->projectDir . $folder . '/organism/' . $atomic_component . '.html.twig')) {
  356. $view = 'platform/component/organism/' . $atomic_component . '.html.twig';
  357. } else {
  358. return $atomic_component . ' not found !';
  359. }
  361. return $this->twig->render($view);
  362. }
  364. /**
  365. * @param $component
  366. * @param $keys
  367. * @param $index
  368. *
  369. * @return mixed
  370. */
  371. private function checkComponent($component, &$keys, $index)
  372. {
  373. $platform = $this->params->get('platform');
  374. $value = $platform;
  375. $keys = explode('.', $component);
  377. $i = 1;
  378. foreach ($keys as $key) {
  379. if (!isset($value[ $key ]) &&
  380. !isset($value[ 'global' ][ $key ]) &&
  381. !isset($value[ 'front' ][ $key ]) &&
  382. !isset($value[ 'back_office' ][ $key ])) {
  383. // On affiche l'erreur de key non trouvée que pour les développeurs.
  384. // En prod et pour les autres utilisateurs, on n'affiche rien (une erreur log est générée néanmoins).
  385. /** @var User $currentUser */
  386. $currentUser = $this->security->getUser();
  387. if ($currentUser !== NULL && $currentUser->isDeveloper()) {
  388. return "key '$key' of '$component' does not exist";
  389. }
  391. $this->logger->error("key '$key' of '$component' does not exist");
  393. return '';
  394. }
  395. if (isset($value[ 'global' ][ $key ])) {
  396. $value = $value[ 'global' ][ $key ];
  397. } elseif (isset($value[ 'front' ][ $key ])) {
  398. $value = $value[ 'front' ][ $key ];
  399. } elseif (isset($value[ 'back_office' ][ $key ])) {
  400. $value = $value[ 'back_office' ][ $key ];
  401. } else {
  402. $value = $value[ $key ];
  403. }
  405. // si un index est passé et qu'on est à la dernière clé, on va chercher l'objet à l'index donné.
  406. if (NULL !== $index && $i === count($keys)) {
  407. $value = $value[ $index ];
  408. }
  409. $i++;
  410. }
  412. return $value;
  413. }
  415. /**
  416. * @throws SyntaxError
  417. * @throws RuntimeError
  418. * @throws LoaderError
  419. */
  420. private function buildComponent($value, $keys, $data, $debug = FALSE): string
  421. {
  422. $response = '<div class="text-danger">' . $value[ 'type' ] . ' not found in components !</div>';
  424. /** @var User $currentUser */
  425. $currentUser = $this->security->getUser();
  427. $componentAclFullKey = is_array($keys) ? implode('.', $keys) : $keys;
  429. $folder = '/templates/platform/component';
  431. if (!(isset($value[ 'disabled' ]) && $value[ 'disabled' ] === TRUE)) {
  432. if (file_exists($this->projectDir . $folder . '/atom/' . $value[ 'type' ] . '.html.twig')) {
  433. $view = 'platform/component/atom/' . $value[ 'type' ] . '.html.twig';
  434. } elseif (file_exists($this->projectDir . $folder . '/molecule/' . $value[ 'type' ] . '.html.twig')) {
  435. $view = 'platform/component/molecule/' . $value[ 'type' ] . '.html.twig';
  436. } elseif (file_exists($this->projectDir . $folder . '/organism/' . $value[ 'type' ] . '.html.twig')) {
  437. $view = 'platform/component/organism/' . $value[ 'type' ] . '.html.twig';
  438. }
  440. if (isset($view)) {
  441. $response = $this->twig->render($view, [
  442. 'value' => $value,
  443. 'data' => $data,
  444. 'componentKey' => $componentAclFullKey,
  445. ]);
  446. }
  447. }
  449. if (isset($view) && $currentUser !== NULL && $currentUser->isDeveloper()) {
  450. $response = "\n<!-- ***** START component " . $value[ 'type' ] . " : " . $view . " ***** -->\n" .
  451. $response .
  452. "\n<!-- ***** END component " . $value[ 'type' ] . " ***** -->\n";
  453. }
  455. return $response;
  456. }
  458. /**
  459. * @param string $page
  460. * @param string $frontType
  461. *
  462. * @return array
  463. * @throws JsonException
  464. */
  465. private function getContentData(string $page, string $frontType): array
  466. {
  467. $cacheKey = $frontType . ':' . $page;
  468. if (array_key_exists($cacheKey, $this->contentDataCache)) {
  469. return $this->contentDataCache[$cacheKey];
  470. }
  472. if (!in_array($frontType, ['security', 'common', 'content'])) {
  473. $frontType = 'content';
  474. }
  476. // on regarde si on a des données en BDD pour cette page
  477. $fromBdd = $this->frontService->getArrayDataFromSetting('front.' . $frontType . '.' . $page);
  479. if ($fromBdd !== []) {
  480. $pageArray = $fromBdd;
  481. } else {
  482. $platform = $this->params->get('platform');
  483. $pageArray = $platform[ 'front' ][ $frontType ];
  484. }
  486. $testPage = explode('.', $page);
  488. if (count($testPage) > 1) {
  489. foreach ($testPage as $item) {
  490. $pageArray = $pageArray[ $item ];
  491. }
  492. } else {
  493. $pageArray = $pageArray[ $page ];
  494. }
  496. return $this->contentDataCache[$cacheKey] = [
  497. 'pageArray' => $pageArray,
  498. 'frontCat' => $frontType,
  499. 'contentKey' => $frontType . '.' . $page,
  500. ];
  501. }
  503. /**
  504. * Génère les div d'ouverture lorsque content() est appelé
  505. *
  506. * TODO à revoir pour verrouiller
  507. *
  508. * container peut avoir plusieurs valeurs
  509. * - TRUE => on ajoute une div class="container" au debut
  510. * - container => on ajoute une div class="container" au debut
  511. * - container-fluid => on ajoute une div class="container-fluid" au debut
  512. * - fluid => on ajoute une div class="container-fluid" au debut
  513. *
  514. * si la clef row existe et n'est pas FALSE => on rajoute une div class="row" après le container
  515. * si la clef row existe et n'est pas FALSE et que la clef row_justify existe => on rajoute une div class="row [valeur de row_justify]" après le container
  516. *
  517. * @param array $pageArray
  518. *
  519. * @return array
  520. */
  521. private function getContentStartDivs(array $pageArray): array
  522. {
  523. $divs = [];
  525. // 3 cas possibles
  526. // la clef n'existe pas ou est à false → pas de container
  527. if (isset($pageArray[ 'container' ])) {
  528. // si la clef est à true ou "container" → container
  529. if (in_array(
  530. $pageArray[ 'container' ],
  531. [TRUE, 'container'],
  532. TRUE
  533. )) {
  534. $divs[] = '<div class="container">';
  535. // si la clef est à "fluid" ou "container-fluid" => container-fluid
  536. } elseif (in_array(
  537. $pageArray[ 'container' ],
  538. ['container-fluid', 'fluid']
  539. )) {
  540. $divs[] = '<div class="container-fluid">';
  541. }
  542. }
  544. if (
  545. isset($pageArray[ 'row' ])
  546. && $pageArray[ 'row' ] !== FALSE
  547. ) {
  548. $row_justify = $pageArray[ 'row_justify' ] ?? '';
  549. $divs[] = '<div class="row ' . $row_justify . '">';
  550. }
  552. return $divs;
  553. }
  555. private function getClassForItem($item)
  556. {
  557. $allClass = $item[ 'class' ] ?? '';
  558. $allClassArray = explode(' ', $allClass);
  560. $classCatArr = [];
  561. if (isset($item[ 'class_category' ])) {
  562. foreach ($item[ 'class_category' ] as $key => $value) {
  563. $classCatArr[ $key ] = !is_array($value) ? explode(' ', $value) : $value;
  564. }
  565. }
  567. $merged = array_merge($allClassArray, ...array_values($classCatArr));
  568. $allClass = array_unique($merged);
  570. return implode(' ', $allClass);
  571. }
  573. public function urlExist($url): bool
  574. {
  575. stream_context_set_default( [
  576. 'ssl' => [
  577. 'verify_peer' => false,
  578. 'verify_peer_name' => false,
  579. ],
  580. ]);
  582. $headers = get_headers($url);
  583. return (bool)stripos($headers[ 0 ], "200 OK");
  584. }
  585. }