vendor\klio\klio-bundle\src\Symfony\RouteController.php line 287

  1. <?php
  3. namespace Klio\KlioBundle\Symfony;
  5. use voku\helper\HtmlMin;
  6. use App\Controller\Routes;
  7. use Klio\KlioBundle\Form\Form;
  8. use Klio\KlioBundle\Files\File;
  9. use Klio\KlioBundle\Files\Image;
  10. use Klio\KlioBundle\Security\Hash;
  11. use Klio\KlioBundle\Security\Crypt;
  12. use Klio\KlioBundle\Security\ClientIp;
  13. use Klio\KlioBundle\Files\UploadedFile;
  14. use Klio\KlioBundle\FileSystem\FsUtils;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HtmlSanitizer\HtmlSanitizerInterface;
  17. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  19. class RouteController extends AbstractController
  20. {
  21.     private Request $request;
  22.     private HtmlSanitizerInterface $sanitizer;
  23.     protected Controller $controller;
  25.     /**
  26.      * les constantes 
  27.      */
  30.     /**
  31.      * On empèche de créer d'autres propriétées que celes d'origine
  32.      *
  33.      * @param [type] $name
  34.      * @param [type] $value
  35.      */
  36.     public function __set($name, $value)
  37.     {
  38.         throw new \Exception("Cannot add or change property \$$name to instance of " . __CLASS__);
  39.     }
  41.     /**
  42.      * Configuration initiale et commune à toutes les routes, création des constantes
  43.      *
  44.      * @param string $configFile Fichier de config complémentaire optionnel
  45.      * @return void
  46.      */
  47.     public function init(string $configFile = ""): void
  48.     {
  50.         $this->request = $this->container->get('request_stack')->getCurrentRequest();
  52.         $this->controller = new Controller($this);
  53.         global $SESSION;
  54.         $SESSION = $this->request->getSession();
  56.         // on defini une constante ROOT qui donne le path vers 
  57.         define('__ROOT__', FsUtils::localPathSanitizer($this->getParameter('kernel.project_dir')));
  58.         define('__PRIVATE__', __ROOT__ . '/private');
  60.         // l'hôte du site
  61.         define('__HOST__', $_SERVER['SERVER_NAME']);
  63.         // mode DEV ?
  64.         define('__DEV__', $_ENV["APP_ENV"] === "dev");
  65.         // mode recette ?
  66.         define("__RECETTE__", @$_ENV['APP_MODE'] === 'recette');
  68.         //Import des variables d'environnement du fichier de conf du store 
  69.         $store = $_ENV['STORE_FOLDER'];
  70.         if (substr($store, 0, 1) == "/" && substr($store, 0, 2) != "//" &&  substr($store, 0, 6) != "/Users") $store = __ROOT__ . $store;
  71.         define("__STORE_FOLDER__",  $store);
  72.         define('__STORE__', $store);
  73.         unset($store);
  75.         // upload folder, dossier ou on stocke tous les fichiers téléchargés
  76.         define('__UPLOAD__', __STORE__ . '/upload');
  78.         define('__APP_USER__', $_ENV["APP_USER"]);
  79.         define('__PHILIPPE__', $_ENV['APP_USER'] === "philippe");
  80.         define('__SAMI__', $_ENV['APP_USER'] === "sami");
  83.         // temp folder
  84.         $temp = $_ENV['TEMP_FOLDER'];
  85.         if (substr($temp, 0, 1) == "/" && substr($temp, 0, 6) != "/Users") $temp = __ROOT__ . $temp;
  86.         define('__TEMP__', $temp);
  87.         unset($temp);
  89.         include_once(__STORE_FOLDER__ . '/Config.php');
  91.         // les éléments liés à l'IP /Klio/Scecurity/ClientIP
  92.         $IP = new ClientIp();
  93.         // l'IP du client
  94.         define("__IP__", $IP->getIp());
  95.         // est-ce une IP KLIO ?
  96.         define("__ISKLIO__", $IP->isKlio());
  97.         // est-ce une IP CAF ?
  98.         define("__ISCAF__", $IP->isCaf());
  99.         // est-ce une IP audit ?
  100.         //define("__ISAUDIT__", $IP->isAudit());
  101.         // est-ce une IP de confiance ?
  102.         define("__SECUREIP__", $IP->isSecure()); //
  103.         // desctruction de l'objet une fois les constantes définies
  104.         unset($IP);
  107.         // clé de salage pour les fonctions de cryptographie 
  108.         define('__SALT__', 'Phu42J;/Q7kBv+8n9zSMxZ+ekAR+EKQc7ZzRéYezz/8twk0F91jD/mq0J,DjC4!ON6%*5tïfZ7sçlg');
  111.         // l'URL appelée par le client, si elle se termine par un slash, on enève le slash final
  112.         $url = $this->request->getPathInfo();
  113.         define('__USER_URL__', $url); // on garde le slash final pour le mode compatibilité avec le FW7 et le FW4 
  114.         if (substr($url, -1) === "/") $url = substr($url, 0, -1);
  115.         define('__URL__', $url);
  117.         // le chemin local, dans /private qui correspond à l'URL
  118.         define('__PATH__', FsUtils::routeSanitizer($this->request->getPathInfo()));
  119.         define('__PATHDIR__', FsUtils::dirSanitizer($this->request->getPathInfo()));
  120.         // public folder path
  121.         define('__PUBLIC__', getcwd());
  125.         // token de session
  126.         if (!$SESSION->get("TOKEN")) {
  127.             $SESSION->set("TOKEN", Hash::uuid62());
  128.         }
  129.         define('__TOKEN__', $SESSION->get("TOKEN"));
  130.         //
  131.         if (!$SESSION->get("CRYPTOKEY")) {
  132.             $SESSION->set("CRYPTOKEY", Crypt::newKey());
  133.         }
  134.         define('__CRYPTOKEY__', $SESSION->get("CRYPTOKEY"));
  135.     }
  138.     /**
  139.      * On traite toutes les variables pour ortenir une reponse soit par du code direct, soit via un twig
  140.      * Cette fonction sert de setter aux deux éléments essentiels : ->response et ->status
  141.      *
  142.      * @return void
  143.      */
  144.     protected function routeResponse()
  145.     {
  147.         /**
  148.          * __URL__ = l'URL saisie
  149.          * les chemins de traitement d'image ou de fichiers
  150.          * on les traite avant les pages car ils peuvet  avoir des caractères spéciaux dans l'URL ( Exemple : /pdf/newsletter/Newsletter%20Janvier.pdf)
  151.          */
  152.         if (stripos(__URL__, '/i/') === 0) {
  153.             /* 
  154.             fontion image
  155.             /i/folder/hash/format/nom_de_l_image.jpg ou /i/folder/hash/nom_de_l_image.jpg
  156.             format : 0x200 , c200x200, c0x200o0x0b100x200
  157.             c = crop
  158.             o = origin
  159.             b = box
  160.             dossier non sécure, on met l'image en cache
  161.             dossier secure, on utilise obligatoirement un php avec test d'accès
  162.             */
  163.             // on peut avoir une fonction personnalisée dans un controller à la racine de private /private/_file/Controller.php
  164.             if (!file_exists(__PRIVATE__ . '/_config/_i/Controller.php')) {
  165.                 Image::getImage(__URL__);
  166.                 exit();
  167.             }
  168.         }
  169.         // téléchargement forcé (image ou pdf ne s'ouvre pas dans le navigateur mais en téléchargement)
  170.         if (stripos(__URL__, '/d/') === 0) {
  171.             // on peut avoir une fonction personnalisée dans un controller à la racine de private /private/_download/Controller.php
  172.             if (!file_exists(__PRIVATE__ . '/_config/routes/_d/Controller.php')) {
  173.                 $file = new File(__URL__);
  174.                 $file->download();
  175.             } else $this->controller->setController('/_config/routes/_d/Controller.php');
  176.         }
  178.         // chargement de fichier (image ou pdf s'ouvre dans le navigateur)
  179.         if (stripos(__URL__, '/f/') === 0) {
  180.             // on peut avoir une fonction personnalisée dans un controller à la racine de private /private/_file/Controller.php
  181.             if (!file_exists(__PRIVATE__ . '/_config/routes/_f/Controller.php')) {
  182.                 $file = new File(__URL__);
  183.                 $file->stream();
  184.             } else $this->controller->setController('/_config/routes/_f/Controller.php');
  185.         }
  187.         // suppression de fichier 
  188.         if (stripos(__URL__, '/delf/') === 0) {
  189.             // on peut avoir une fonction personnalisée dans un controller à la racine de private /private/_file/Controller.php
  190.             if (file_exists(__PRIVATE__ . '/_config/routes/_delf/Controller.php')) {
  191.                 $this->controller->setController('/_config/routes/_delf/Controller.php');
  192.             } else die("Error DELFILE");
  193.         }
  195.         // fichier PDF, éventuellement créé à la volée
  196.         if (stripos(__URL__, '/p/') === 0) {
  197.             /* 
  198.             function pdf 
  199.             /p/folder/hash/nom_de_fichier.pdf ou /p/folder/fonction_de_generation_de_pdf/id_source/nom_de_fichier.pdf
  200.             */
  201.         }
  203.         // on teste l'url pour vérifier si elle est
  204.         if (!$this->checkPath()) {
  205.             $this->controller->routeCancel = true; // on marque la route comme trouvée pour ne pas chercher 
  206.             $this->send404(); // on renvoie d'office un 404 notfound 
  207.         }
  208.         /*
  209.          * si la route est propre, on inclut le code du controller
  210.          * soit celui par défaut (Controller.php dans le dossier /private qui correspond à __PATH__), soit celui qui a été indiqué via $this>setController()
  211.          * la fonction includePrivateController dira s'occupe de definir $this->controller->routeFound
  212.          */ else $this->controller->includePrivateController();
  213.     }
  215.     /** 
  216.      *  
  217.      * dans FsUtils::routeSanitizer on définie une constante __PATH__ "propre". L'URL sans aucun caractère spéciaux (uniquement A-Za-z0-9_-)
  218.      * __PATH__ est censé donner le chemin dans /private
  219.      * URL et PATH doivent être identiques
  220.      * si l'URL n'est pas propre, on considère que c'est une tentative de hack, on bloque la demande   
  221.      * 
  222.      * @return void  */
  223.     protected function checkPath(): bool
  224.     {
  225.         $path = __PATH__;
  226.         $url = __URL__;
  228.         // upload de fichier V4
  229.         if (strpos(__URL__, '/upload/files/') === 0) return true;
  232.         // si l'URL commence par /FW7/ ou /FW4/, on est en mode compatibilité, on a le droit d'appeller directement un fichier php uniquement. 
  233.         if (
  234.             (strpos(__URL__, '/FW4/') === 0
  235.                 or strpos(__URL__, '/FW7/') === 0
  236.                 or strpos(__URL__, '/k4/') === 0
  237.             ) and strtolower(substr(__URL__, -4)) === '.php'
  238.         ) {
  239.             return true;
  240.         }
  241.         // les chemins spéciaux : /d/ /f/ /i/
  242.         if (
  243.             (stripos(__URL__, '/d/') === 0
  244.                 or stripos(__URL__, '/i/') === 0
  245.                 or stripos(__URL__, '/f/') === 0
  246.                 or stripos(__URL__, '/p/') === 0
  247.             )
  248.         ) return true;
  250.         // cas particulier pour la home
  251.         if ($path === '/' and $url == '') return true;
  252.         // sinon, on doit être égal
  253.         //dump($path);
  254.         // dd($url);
  256.         return ($path === $url);
  257.     }
  259.     protected function routeFound(): bool
  260.     {
  261.         return $this->controller->getRouteFound();
  262.     }
  265.     /**
  266.      * Défini le fichier php qui va être include dans l'objet Controller pour y ajouter une logique
  267.      *
  268.      * @param string $controllerFile Le path/name du .php
  269.      * @return string
  270.      */
  271.     protected function setController(string $controllerFile): string
  272.     {
  273.         $this->controller->setController($controllerFile);
  274.         return $this->controller->getController();
  275.     }
  279.     protected function addController(string $controllerFile): array
  280.     {
  281.         $this->controller->addController($controllerFile);
  282.         return $this->controller->getControllers();
  283.     }
  285.     protected function getResponse(): string
  286.     {
  287.         $this->routeResponse();
  288.         $this->routeRender();
  289.         return $this->controller->getResponse();
  290.     }
  292.     protected function getStatus(): string
  293.     {
  294.         return $this->controller->getStatus();
  295.     }
  297.     private function encore()
  298.     {
  300.         // on init les deux tableaux pour les JS et les CSS
  301.         $encore = [];
  302.         $encore['encore_js'] = [];
  303.         $encore['encore_css'] = [];
  305.         $jsArray = $this->controller->getJs();
  306.         foreach ($jsArray as $idx => $js) {
  307.             if (!str_starts_with($js, '/')) $js = $this->controller->getControllerPath() . '/' . $js;
  308.             $js = str_replace('//', '/', $js);
  309.             $jsArray[$idx] = $js;
  310.             $encore['encore_js'][] = md5("./private" . $js);
  311.         }
  312.         $this->controller->setJs($jsArray);
  314.         $cssArray = $this->controller->getCss();
  315.         foreach ($cssArray as $idx => $css) {
  316.             if (!str_starts_with($css, '/')) $css = $this->controller->getControllerPath() . '/' . $css;
  317.             $css = str_replace('//', '/', $css);
  318.             $cssArray[$idx] = $css;
  319.             $encore['encore_css'][] = md5("./private" . $css);
  320.         }
  321.         $this->controller->setCss($cssArray);
  323.         $this->controller->addTwig($encore);
  324.     }
  327.     /**
  328.      * 
  329.      * Faire le rendu du Twig
  330.      * 
  331.      * par défaut le TWIG, c'est le fichier Template.twig dans le même dossier que le Controller.php
  332.      * mais on peut dans le controller choisir d'appeller un autre TWIG
  333.      * en renseigant $RESPONSE->template en donnant au choix
  334.      * un chemin absolu qui commence par 
  335.      * Exemple /test/tmp.twig  va chercher dans /private/test/tmp.twig ou /templates/test/tmp.twig
  336.      * Exemple /tmp.twig  va chercher dans /private/tmp.twig ou /templates/tmp.twig
  337.      * un chemin relatif sans / : Autre.twig pour chercher dans le même dosssier que le Controller.php
  338.      * Exemple : Template2.twig va chercher dans le même dosssier que le controller le fichier Template2.twig
  339.      * 
  340.      */
  341.     public function routeRender()
  342.     {
  343.         // si on a déjà une réponse via getResponse, pas besoin d'aller chercher le twig
  344.         // le twig n'est là que pour remplir controller->response
  345.         if ($this->controller->getResponse()) return true;
  347.         // à ce stade, si la route n'est pas trouvée, on renvoi un 404
  348.         if (!$this->controller->getRouteFound()) $this->send404();
  349.         // le template
  350.         $template = $this->controller->getTemplate();
  352.         if (!$template) {
  353.             $path = $this->controller->getControllerPath();
  354.             if ($this->routeFound()) $template = ($path == '/' ? $path : $path . '/') . "Template.twig";
  355.         } else if (!str_starts_with($template, '/')) $template = $this->controller->getControllerPath() . "/" . $template;
  357.         $this->controller->setTemplate($template);
  359.         // les listes de JS et les CSS associés
  360.         $this->encore();
  362.         // le rendu du template pour obtenir la réponse
  363.         $this->controller->setResponse($this->renderView($this->controller->getTemplate(), $this->controller->getTwig()));
  365.         $this->outputBuffer();
  367.         //if (__DEV__) dump($this->controller);
  368.     }
  371.     /**
  372.      * mise à jour du code initial en le faisant passer à travers un buffer de sortie
  373.      *
  374.      * @param Controller &$CONTROLLER
  375.      * @param string $template
  376.      * @return void
  377.      */
  378.     private function outputBuffer()
  379.     {
  380.         $response = $this->controller->getResponse();
  382.         //on charge SimpleDomHtml
  383.         //require_once __FW__ . '/php/libs/simplehtmldom_1_9_1/simple_html_dom.php';
  384.         //require_once __ROOT__ . '/vendor/simplehtmldom/simplehtmldom/simple_html_dom.php';
  385.         require_once $_ENV['PACKAGES_FOLDER'] . "/frameworks/simplehtmldom_1_9_1/simple_html_dom.php";
  386.         $DOM = str_get_html($response, $lowercase = true, $forceTagsClosed = true, $target_charset = DEFAULT_TARGET_CHARSET, $stripRN = false, $defaultBRText = DEFAULT_BR_TEXT, $defaultSpanText = DEFAULT_SPAN_TEXT);
  388.         // traitement du form
  389.         // on fait passer le code de sortie à travers cette fonction pour changer le code à l'intérieur des form
  390.         if ($DOM) {
  392.             foreach ($DOM->find('form') as $form) {
  393.                 if (!$form->getAttribute('nobuffer')) new Form($form, $DOM);
  394.             }
  395.             // si l'objet response à sa propre function de buffer (pour un traitement spécifique du code de sortie)
  396.             // on appelle cette fonction
  397.             if ($this->controller->getBuffer() and is_callable('\App\Controller\OutputBuffers::' . $this->controller->getBuffer())) {
  398.                 //call_user_func('\App\Controller\OutputBuffers::' . $this->controller->getBuffer(), $DOM, $this->controller);
  399.             }
  401.             /**
  402.              * on sauve le résultat modifié dans le code de sortie de l'objet response
  403.              */
  405.             $response = $DOM->save();
  406.             $DOM->clear();
  407.             unset($DOM);
  409.             //$htmlMin = new HtmlMin();
  410.             //$response = $htmlMin->minify($response);
  411.             // le minifier de voku supprime les balises </body></html> ce qui est correct au sens du html5 mais enmpèche symfony de positionner la debug bar
  412.             // on remet donc les balises juste pour ce besoin
  413.             //if (__DEV__ and stripos($response, '<html>') !== false) $response .= '</body></html>';
  414.         }
  416.         $this->controller->setResponse($response);
  417.     }
  419.     /**
  420.      * Annule la route et envoie un 404
  421.      *
  422.      * @return bool
  423.      */
  424.     public function send404(): void
  425.     {
  426.         $this->controller->setStatus(404);
  427.         $this->controller->setTemplate('/404.twig');
  428.         $this->controller->setTwig(["status" => "404", "message" => "Page introuvable."]);
  429.         if (is_callable('App\Controller\Routes::notFound')) Routes::notFound($this->controller);
  430.     }
  431. }