src\Controller\Routes.php line 174

  1. <?php
  3. namespace App\Controller;
  5. use LogicException;
  6. use App\Objects\User\User;
  7. use App\Objects\Redirection;
  8. use Klio\KlioBundle\Security\Hash;
  9. use Klio\KlioBundle\Security\Sanitizer;
  10. use Klio\KlioBundle\Symfony\Controller;
  11. use Klio\KlioBundle\Symfony\RouteController;
  12. use Psr\Container\NotFoundExceptionInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Psr\Container\ContainerExceptionInterface;
  15. use Symfony\Component\HttpFoundation\Response;
  16. use Symfony\Component\Routing\Annotation\Route;
  17. use Symfony\Component\HtmlSanitizer\HtmlSanitizerConfig;
  18. use Symfony\Component\HtmlSanitizer\HtmlSanitizerInterface;
  20. class Routes extends RouteController
  21. {
  24.     /**
  25.      * @param HtmlSanitizerInterface $htmlSanitizer
  26.      * @param Request $request 
  27.      * @return Response 
  28.      * @throws LogicException 
  29.      * @throws NotFoundExceptionInterface 
  30.      * @throws ContainerExceptionInterface 
  31.      */
  32.     #[Route(
  33.         '/FW7/{subpath}',
  34.         name: 'FW7',
  35.         methods: ['GET', 'HEAD', 'POST'],
  36.         requirements: ['subpath' => '.*']
  37.     )]
  38.     public function FW7(Request $request, HtmlSanitizerInterface $sanitizer): Response
  39.     {
  41.         ob_clean();
  43.         // initialize l'object RouteController 
  44.         // defini les constantes avec un fichier de config en option
  45.         $this->init(); // $this->init("/private/Config.php");
  47.         //$Sanitizer = new Sanitizer("body");
  48.         global $FW;
  49.         require_once($_ENV['PACKAGES_FOLDER'] . '/frameworks/FW7/prepend_FW7.php');
  51.         /* === la logique propre à ce groupe de routes === */
  52.         // on force toutes ces routes à utiliser le même controller spécifique
  53.         $this->setController('/FW7/Controller7.php');
  54.         /* === la logique propre à ce groupe de routes === */
  56.         // On renvoie le résultat
  57.         return new Response($this->getResponse(), $this->getStatus());
  58.     }
  61.     /**
  62.      * @param HtmlSanitizerInterface $htmlSanitizer
  63.      * @param Request $request 
  64.      * @return Response 
  65.      * @throws LogicException 
  66.      * @throws NotFoundExceptionInterface 
  67.      * @throws ContainerExceptionInterface 
  68.      */
  69.     #[Route(
  70.         '/admin{subpath}',
  71.         name: 'admin',
  72.         methods: ['GET', 'HEAD', 'POST'],
  73.         requirements: ['subpath' => '^.{0}|/.*$']
  74.     )]
  75.     public function admin(Request $request, HtmlSanitizerInterface $sanitizer): Response
  76.     {
  78.         // les varaibales de base
  79.         $this->init();
  81.         // authentifiction
  82.         global $USER;
  83.         $USER = new User();
  85.         if (!$USER->auth()) $this->setController('/_login/Controller.php');
  87.         //$this->setController('/FW7/admin/Controller7.php');
  88.         /* === la logique propre à ce groupe de routes === */
  90.         // On renvoie le résultat
  91.         return new Response($this->getResponse(), $this->getStatus());
  92.     }
  94.     /**
  95.      * @param Request $request 
  96.      * @return Response 
  97.      * @throws LogicException 
  98.      * @throws NotFoundExceptionInterface 
  99.      * @throws ContainerExceptionInterface 
  100.      */
  101.     #[Route(
  102.         '/actualites/{subpath}',
  103.         name: 'actualites',
  104.         methods: ['GET', 'HEAD', 'POST'],
  105.         requirements: ['subpath' => '.+$']
  106.     )]
  108.     public function actualites(HtmlSanitizerInterface $sanitizer, Request $request): Response
  109.     {
  110.         // initialize l'object RouteController 
  111.         $this->init(); // $this->init("/private/Config.php");
  113.         // Redirection
  114.         Redirection::verifHost();
  116.         /* === la logique propre à ce groupe de routes === */
  117.         // on force toutes ces routes à utiliser le même controller spécifique
  118.         $this->setController('/actualites/Controller.php');
  120.         // On renvoie le résultat
  121.         return new Response($this->getResponse(), $this->getStatus());
  122.     }
  126.     /**
  127.      * @param Request $request 
  128.      * @return Response 
  129.      * @throws LogicException 
  130.      * @throws NotFoundExceptionInterface 
  131.      * @throws ContainerExceptionInterface 
  132.      */
  133.     #[Route(
  134.         '/{subpath}',
  135.         name: 'page',
  136.         methods: ['GET', 'HEAD', 'POST'],
  137.         requirements: ['subpath' => ".*(?:formation|paie|conseil|cooperative|mediation|bureau_danse|mentions_legales)\b(\/.*|.{0})"],
  138.     )]
  140.     public function page(Request $request, HtmlSanitizerInterface $sanitizer): Response
  141.     {
  142.         // initialize l'object RouteController 
  143.         // defini les constantes avec un fichier de config en option
  144.         $this->init(); // $this->init("/private/Config.php");
  146.         // Redirection
  147.         Redirection::verifHost();
  149.         /* === la logique propre à ce groupe de routes === */
  150.         // on ajoute un controller au controller /path/Controller.php
  151.         $this->setController('/page/Controller.php');
  152.         /* === la logique propre à ce groupe de routes === */
  154.         // On renvoie le résultat
  155.         return new Response($this->getResponse(), $this->getStatus());
  156.     }
  160.     /**
  161.      * @param Request $request 
  162.      * @return Response 
  163.      * @throws LogicException 
  164.      * @throws NotFoundExceptionInterface 
  165.      * @throws ContainerExceptionInterface 
  166.      */
  167.     #[Route(
  168.         '/{subpath}',
  169.         name: 'formations',
  170.         methods: ['GET', 'HEAD', 'POST'],
  171.         requirements: ['subpath' => ".*formations"],
  172.     )]
  174.     public function formations(Request $request, HtmlSanitizerInterface $sanitizer): Response
  175.     {
  176.         // initialize l'object RouteController 
  177.         // defini les constantes avec un fichier de config en option
  178.         $this->init(); // $this->init("/private/Config.php");
  180.         // Redirection
  181.         Redirection::verifHost();
  183.         /* === la logique propre à ce groupe de routes === */
  184.         // on ajoute un controller au controller /path/Controller.php
  185.         $this->setController('/formations/Controller.php');
  186.         /* === la logique propre à ce groupe de routes === */
  188.         // On renvoie le résultat
  189.         return new Response($this->getResponse(), $this->getStatus());
  190.     }
  194.     /**
  195.      * @param Request $request 
  196.      * @return Response 
  197.      * @throws LogicException 
  198.      * @throws NotFoundExceptionInterface 
  199.      * @throws ContainerExceptionInterface 
  200.      */
  201.     #[Route(
  202.         '/formations/{subpath}',
  203.         name: 'formation',
  204.         methods: ['GET', 'HEAD', 'POST'],
  205.         requirements: ['subpath' => ".+$"],
  206.     )]
  208.     public function formation(Request $request, HtmlSanitizerInterface $sanitizer): Response
  209.     {
  210.         $subpath = $request->attributes->get('_route_params')["subpath"];
  212.         // initialize l'object RouteController 
  213.         // defini les constantes avec un fichier de config en option
  214.         $this->init(); // $this->init("/private/Config.php");
  216.         // Redirection
  217.         Redirection::verifHost();
  219.         /* === la logique propre à ce groupe de routes === */
  220.         // on ajoute un controller au controller /path/Controller.php
  221.         if ($subpath === "detail")
  222.             $this->setController('/formations/detail/Controller.php');
  223.         else
  224.             $this->setController('/formations/formation/Controller.php');
  225.         /* === la logique propre à ce groupe de routes === */
  227.         // On renvoie le résultat
  228.         return new Response($this->getResponse(), $this->getStatus());
  229.     }
  232.     /**
  233.      * @param Request $request 
  234.      * @return Response 
  235.      * @throws LogicException 
  236.      * @throws NotFoundExceptionInterface 
  237.      * @throws ContainerExceptionInterface 
  238.      */
  239.     #[Route(
  240.         '/formations_partenaires/{subpath}',
  241.         name: 'formation-partenaire',
  242.         methods: ['GET', 'HEAD', 'POST'],
  243.         requirements: ['subpath' => ".+$"],
  244.     )]
  246.     public function formationPartenaire(Request $request, HtmlSanitizerInterface $sanitizer): Response
  247.     {
  248.         $subpath = $request->attributes->get('_route_params')["subpath"];
  250.         // initialize l'object RouteController 
  251.         // defini les constantes avec un fichier de config en option
  252.         $this->init(); // $this->init("/private/Config.php");
  254.         // Redirection
  255.         Redirection::verifHost();
  257.         /* === la logique propre à ce groupe de routes === */
  258.         // on ajoute un controller au controller /path/Controller.php
  259.         if ($subpath === "detail")
  260.             $this->setController('/formations_partenaires/detail/Controller.php');
  261.         else
  262.             $this->setController('/formations_partenaires/formation/Controller.php');
  263.         /* === la logique propre à ce groupe de routes === */
  265.         // On renvoie le résultat
  266.         return new Response($this->getResponse(), $this->getStatus());
  267.     }
  270.     /**
  271.      * @param Request $request 
  272.      * @return Response 
  273.      * @throws LogicException 
  274.      * @throws NotFoundExceptionInterface 
  275.      * @throws ContainerExceptionInterface 
  276.      */
  277.     #[Route(
  278.         '/{subpath}',
  279.         name: 'all',
  280.         methods: ['GET', 'HEAD', 'POST'],
  281.         requirements: ['subpath' => ".*"],
  282.     )]
  284.     public function all(Request $request, HtmlSanitizerInterface $sanitizer): Response
  285.     {
  287.         // initialize l'object RouteController 
  288.         // defini les constantes avec un fichier de config en option
  289.         $this->init(); // $this->init("/private/Config.php");
  291.         // Redirection
  292.         Redirection::verifHost();
  294.         /* === la logique propre à ce groupe de routes === */
  295.         // on ajoute un controller au controller /path/Controller.php
  296.         //$this->setController('/page/Controller.php');
  297.         /* === la logique propre à ce groupe de routes === */
  299.         // On renvoie le résultat
  300.         return new Response($this->getResponse(), $this->getStatus());
  301.     }
  305.     /**
  306.      * Routes::notFound(Controller) défini le comportement du site en cas de d'erreur 404
  307.      * on peut renvoyer certaines infos, choisir d'inclure un Template404.twig spécifique, ou inclure une ogique pour des 404 différenciés
  308.      * on renvoyer en général un $CONTROLLER->setTemplate(string) (on peut ajouter des variables twig $CONTROLLER->setTwig(array)) et un $CONTROLLER->setStatus(404)
  309.      * Mais on peut aussi renvoyer un $CONTROLLER->setResponse(string) pour certaines routes de type API
  310.      *
  311.      * @param Controller $CONTROLLER
  312.      * @return void
  313.      */
  314.     public static function notFound(Controller &$CONTROLLER)
  315.     {
  316.         $CONTROLLER->setStatus(404);
  317.         if (str_contains(__URL__, "/formations/") || str_contains(__URL__, "/formations_partenaires/"))
  318.             $CONTROLLER->setTemplate('/404formation.twig');
  319.         else
  320.             $CONTROLLER->setTemplate('/404.twig');
  321.     }
  322. }