src/Twig/Runtime/PlatformComponentRuntime.php line 97

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