src/Twig/Runtime/PlatformComponentRuntime.php line 413

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.     }