src/Twig/Runtime/PlatformComponentRuntime.php line 96

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