src/Twig/Runtime/PlatformComponentRuntime.php line 93

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