vendor\klio\klio-bundle\src\Symfony\Controller.php line 64

  1. <?php
  3. namespace Klio\KlioBundle\Symfony;
  5. use Klio\KlioBundle\Debug\Error;
  6. use Klio\KlioBundle\Security\Sanitizer;
  8. /**
  9.  * Cette classe sert uniquement à isoler le Controller.php include dans un espace cadré et borné 
  10.  */
  11. class Controller
  12. {
  13.     private string|false $template = false; // le template twig si on a pas envoyé le code via $response 
  14.     private int $status = 0; // le statut de la réponse, 200, 404, etc...
  15.     private array $js = []; // l'injection dans le twig de Scrips.js dans le dossier via webpack
  16.     private array  $css = [];
  17.     private string $buffer = "";
  18.     private array $controllers = []; // les fichiers controller .php avec chemin depuis le root /private/test/TestController.php
  19.     private string $controller = ""; // le fichier controller actif
  20.     private array $twig = [];
  21.     private bool $routeFound = false; // la route a été trouvée ou pas
  22.     public bool $routeCancel = false; // si l'URL n'est pas propre, on annule l'appel à la route
  23.     private string $controllerPath = ""; // en fonciton du controller, on determine la route qui va avec
  24.     // response est en dernier pour qu'il soit en bas dans le dump
  25.     private string $response = ""; // le code html à envoyer au client
  26.     private Sanitizer $sanitizer;
  27.     private object $privateController;
  29.     public function __construct()
  30.     {
  31.         $this->sanitizer = new Sanitizer();
  32.     }
  34.     /** Renvoie le controller par défaut à partir du path
  35.      *  @return string Le fichier Controller.php à include par défaut dans l'objet COntroller
  36.      */
  37.     private function getDefaultController(): string
  38.     {
  39.         return __PATH__ == '/' ? '' . "/Controller.php" : strtolower(__PATH__) . "/Controller.php";
  40.     }
  43.     /**
  44.      * Affectation d'un controller
  45.      *
  46.      * @return string
  47.      */
  48.     public function setController(string $controllerFile): string
  49.     {
  50.         if (!$this->controllers) $this->controllers[] = $controllerFile;
  51.         $this->controller = $controllerFile;
  52.         $this->controllerPath = dirname($controllerFile);
  54.         return $this->controller;
  55.     }
  58.     /**
  59.      * Include du fichier php controller dans private
  60.      * Défini deux éléments essentiels : ->response et ->status
  61.      *
  62.      * @return bool|int
  63.      */
  64.     public function includePrivateController()
  65.     {
  67.         // si le controller est défini de force ou avant, on l'utilise 
  68.         if ($this->getController()) {
  69.             $this->setRouteFound(@include_once(__ROOT__ . "/private" . $this->getController()));
  70.         }
  71.         // sinon, on teste les controllers un par un
  72.         else {
  74.             if (!$this->controllers) {
  75.                 $this->controllers[] = $this->getDefaultController();
  76.             }
  77.             // on essaye d'include tous les controller dans l'ordre
  78.             foreach ($this->controllers as $controller) {
  79.                 // on affecte la nouvelle route du nouveau controller
  80.                 $this->setRouteFound(@include_once(__ROOT__ . "/private" . $controller));
  81.                 if ($this->getRouteFound()) {
  82.                     $this->setController($controller);
  83.                     break;
  84.                 }
  85.             }
  86.         }
  88.         // si le fichier php du controller dans le chemin private a été trouvé, on créé l'objet PrivateController à partir de ce fichier php.
  89.         if ($this->getRouteFound()) {
  90.             // la classe PrivateController est un objet qui est construit dans chaque route, il permet d'accèder à l'objet Controller tout en instanciant une classe privée à chaque fois
  91.             $this->privateController = new \PrivateController($this);
  92.             $this->privateController->render($this);
  93.             // on ajoute par défaut la session auth
  94.             if (isset($_SESSION['auth'])) $this->addTwig('auth', $_SESSION['auth']);
  95.             if (isset($_SESSION['twig'])) $this->addTwig('twig', $_SESSION['twig']);
  96.         }
  97.         return $this->getRouteFound();
  98.     }
  101.     /**
  102.      * Ajoute d'un controller a tester
  103.      *
  104.      * @return array
  105.      */
  106.     public function addController(string $controllerFile): array
  107.     {
  108.         if (!$this->controllers) {
  109.             $this->controllers[] = $this->getDefaultController();
  110.         }
  111.         $this->controllers[] = $controllerFile;
  112.         return $this->controllers;
  113.     }
  115.     /*
  116.      * La liste des controllers
  117.      *
  118.      * @return array
  119.      */
  120.     public function getControllers(): array
  121.     {
  122.         return $this->controllers;
  123.     }
  125.     /*
  126.      * on cherche le controller actif
  127.      *
  128.      * @return string
  129.      */
  130.     public function getController(): string
  131.     {
  132.         return $this->controller;
  133.     }
  134.     /**
  135.      * renvoi $controller->controllerPath 
  136.      *
  137.      * @return string
  138.      */
  139.     public function getControllerPath(): string
  140.     {
  141.         if ($this->controllerPath) return $this->controllerPath;
  142.         else return dirname($this->controller);
  143.     }
  146.     /**
  147.      * Getter : le code brut (html, json, xml...) à renvoyer au client
  148.      *
  149.      * @return string
  150.      */
  151.     public function getResponse(): string
  152.     {
  153.         return $this->response;
  154.     }
  156.     /**
  157.      * Setter : le code brut (html, json, xml...) qui va être renvoyé au client
  158.      *
  159.      * @param string $response le code brut (html, json, xml...) qui va être renvoyé
  160.      *
  161.      * @return string
  162.      */
  163.     public function setResponse(string $response, int $status = 0): string
  164.     {
  166.         if ($response and !$this->getStatus() and !$status) $this->setStatus(200);
  167.         if ($status) $this->setStatus($status);
  168.         $this->response = $response;
  169.         return $this->response;
  170.     }
  172.     /**
  173.      * Get the value of status
  174.      *
  175.      * @return int
  176.      */
  177.     public function getStatus(): int
  178.     {
  179.         if (!$this->getResponse() and !$this->getTemplate()) return 0;
  180.         if (($this->getResponse() or $this->getTemplate()) and !$this->status) return 200;
  181.         return $this->status;
  182.     }
  184.     /**
  185.      * Set the value of status
  186.      *
  187.      * @param int $status
  188.      *
  189.      * @return self
  190.      */
  191.     public function setStatus(int $status): int
  192.     {
  193.         $this->status = $status;
  194.         return $this->status;
  195.     }
  197.     /**
  198.      * Get the value of template
  199.      *
  200.      * @return string|false
  201.      */
  202.     public function getTemplate(): string|false
  203.     {
  204.         return $this->template;
  205.     }
  207.     /**
  208.      * Set the value of template
  209.      *
  210.      * @param string $template
  211.      *
  212.      * @return string
  213.      */
  214.     public function setTemplate(string|false $templateFile): string|false
  215.     {
  216.         if ($templateFile and $this->response) new Error([
  217.             "msg" => "Erreur Controller->setTemplate",
  218.             "debug" => "Impossible de régler un template si la route renvoie déjà une réponse.",
  219.             "datas" => $this
  220.         ]);
  221.         if ($templateFile and !$this->getStatus()) $this->setStatus(200);
  222.         $this->template = $templateFile;
  223.         return $this->template;
  224.     }
  226.     /**
  227.      * Get the value of js
  228.      *
  229.      * @return array
  230.      */
  231.     public function getJs(): array
  232.     {
  233.         return $this->js;
  234.     }
  236.     /**
  237.      * Set the value of js
  238.      *
  239.      * @param array $js
  240.      *
  241.      * @return self
  242.      */
  243.     public function setJs(array $js): array
  244.     {
  245.         $this->js = $js;
  246.         return $this->js;
  247.     }
  249.     /**
  250.      * Add values to css
  251.      *
  252.      * @param array $css
  253.      *
  254.      * @return self
  255.      */
  256.     public function addJs(array|string $js): array
  257.     {
  258.         if (is_array($js)) {
  259.             foreach ($js as $file) {
  260.                 $this->js[] = $file;
  261.             }
  262.         } else $this->js[] = $js;
  264.         return $this->js;
  265.     }
  267.     /**
  268.      * Get the value of css
  269.      *
  270.      * @return array
  271.      */
  272.     public function getCss(): array
  273.     {
  274.         return $this->css;
  275.     }
  277.     /**
  278.      * Set the value of css
  279.      *
  280.      * @param array $css
  281.      *
  282.      * @return self
  283.      */
  284.     public function setCss(array $css): array
  285.     {
  286.         $this->css = $css;
  288.         return $this->css;
  289.     }
  292.     /**
  293.      * Add values to css
  294.      *
  295.      * @param array $css
  296.      *
  297.      * @return self
  298.      */
  299.     public function addCss(array|string $css): array
  300.     {
  301.         if (is_array($css)) {
  302.             foreach ($css as $file) {
  303.                 $this->css[] = $file;
  304.             }
  305.         } else $this->css[] = $css;
  307.         return $this->css;
  308.     }
  311.     /**
  312.      * Get the value of buffer
  313.      *
  314.      * @return string
  315.      */
  316.     public function getBuffer(): string
  317.     {
  318.         return $this->buffer;
  319.     }
  321.     /**
  322.      * Set the value of buffer
  323.      *
  324.      * @param string $buffer
  325.      *
  326.      * @return self
  327.      */
  328.     public function setBuffer(string $buffer): string
  329.     {
  330.         $this->buffer = $buffer;
  331.         return $this->buffer;
  332.     }
  334.     /**
  335.      * Get the value of twig
  336.      *
  337.      * @return array|string
  338.      */
  339.     public function getTwig(string $key = ""): array|string
  340.     {
  341.         if (!$key) return $this->twig;
  342.         else return $this->twig[$key];
  343.     }
  345.     /**
  346.      * Affecter un tableau à ->twig, toute la liste des keys/values en une seule fois
  347.      *
  348.      * @param array $keysvals un tableau clés/valeurs avec toutes les varaibles twig
  349.      *
  350.      * @return self
  351.      */
  352.     public function setTwig(array|string $keysvals, string|array $value = ""): array
  353.     {
  354.         $this->twig = [];
  355.         $this->addTwig($keysvals, $value);
  356.         return $this->twig;
  357.     }
  359.     /**
  360.      * ajoute une variable twig ou un tableau de variables sanitizées
  361.      *
  362.      * @param string $key la clé du tableau
  363.      * @param string $val la valeur de la clé
  364.      * @param string $encodeEntities forcer l'encodage des htmlentities
  365.      *
  366.      * @return self
  367.      */
  368.     public function addTwig(array|string $keysvals, string|array $value = "", $encodeEntities = false): array
  369.     {
  370.         if (is_array($keysvals)) {
  371.             foreach ($keysvals as $key => $val) {
  372.                 $this->twig[$key] = $this->sanitizer->sanitize($val, $encodeEntities);
  373.             }
  374.         } else $this->twig[$keysvals] = $this->sanitizer->sanitize($value, $encodeEntities);
  375.         return $this->twig;
  376.     }
  378.     /**
  379.      * ajoute une variable twig ou un tableau de variables de confiance non sanitizées
  380.      *
  381.      * @param string $key la clé du tableau
  382.      * @param string $val la valeur de la clé
  383.      * @param string $encodeEntities forcer l'encodage des htmlentities
  384.      *
  385.      * @return self
  386.      */
  387.     public function addTrustedTwig(array|string $keysvals, string|array $value = "", $encodeEntities = false): array
  388.     {
  389.         if (is_array($keysvals)) {
  390.             foreach ($keysvals as $key => $val) {
  391.                 $this->twig[$key] = $val;
  392.             }
  393.         } else $this->twig[$keysvals] = $value;
  394.         return $this->twig;
  395.     }
  397.     /**
  398.      * retirer une clé du tableau twig
  399.      *
  400.      * @param string $key
  401.      *
  402.      * @return self
  403.      */
  404.     public function removeTwig(string $key): array
  405.     {
  406.         unset($this->twig[$key]);
  408.         return $this->twig;
  409.     }
  411.     /**
  412.      * Get the value of routeFound
  413.      *
  414.      * @return bool
  415.      */
  416.     public function getRouteFound(): bool
  417.     {
  418.         return $this->routeFound;
  419.     }
  421.     /**
  422.      * Set the value of routeFound
  423.      *
  424.      * @param bool $routeFound
  425.      *
  426.      * @return void
  427.      */
  428.     public function setRouteFound(bool $routeFound): void
  429.     {
  430.         $this->routeFound = $routeFound;
  431.     }
  432. }