src/Twig/Runtime/PlatformComponentRuntime.php line 101

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