src\Controller\Routes.php line 172

  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.     }
  158.     /**
  159.      * @param Request $request 
  160.      * @return Response 
  161.      * @throws LogicException 
  162.      * @throws NotFoundExceptionInterface 
  163.      * @throws ContainerExceptionInterface 
  164.      */
  165.     #[Route(
  166.         '/{subpath}',
  167.         name: 'formations',
  168.         methods: ['GET', 'HEAD', 'POST'],
  169.         requirements: ['subpath' => "formations"],
  170.     )]
  172.     public function formations(Request $request, HtmlSanitizerInterface $sanitizer): Response
  173.     {
  174.         // initialize l'object RouteController 
  175.         // defini les constantes avec un fichier de config en option
  176.         $this->init(); // $this->init("/private/Config.php");
  178.         // Redirection
  179.         Redirection::verifHost();
  181.         /* === la logique propre à ce groupe de routes === */
  182.         // on ajoute un controller au controller /path/Controller.php
  183.         $this->setController('/formations/Controller.php');
  184.         /* === la logique propre à ce groupe de routes === */
  186.         // On renvoie le résultat
  187.         return new Response($this->getResponse(), $this->getStatus());
  188.     }
  190.     /**
  191.      * @param Request $request 
  192.      * @return Response 
  193.      * @throws LogicException 
  194.      * @throws NotFoundExceptionInterface 
  195.      * @throws ContainerExceptionInterface 
  196.      */
  197.     #[Route(
  198.         '/formations/{subpath}',
  199.         name: 'formation',
  200.         methods: ['GET', 'HEAD', 'POST'],
  201.         requirements: ['subpath' => ".+$"],
  202.     )]
  204.     public function formation(Request $request, HtmlSanitizerInterface $sanitizer): Response
  205.     {
  206.         // initialize l'object RouteController 
  207.         // defini les constantes avec un fichier de config en option
  208.         $this->init(); // $this->init("/private/Config.php");
  210.         // Redirection
  211.         Redirection::verifHost();
  213.         /* === la logique propre à ce groupe de routes === */
  214.         // on ajoute un controller au controller /path/Controller.php
  215.         if (isset($_GET["id"]))
  216.             $this->setController('/formations/detail/Controller.php');
  217.         else
  218.             $this->setController('/formations/formation/Controller.php');
  219.         /* === la logique propre à ce groupe de routes === */
  221.         // On renvoie le résultat
  222.         return new Response($this->getResponse(), $this->getStatus());
  223.     }
  226.     /**
  227.      * @param Request $request 
  228.      * @return Response 
  229.      * @throws LogicException 
  230.      * @throws NotFoundExceptionInterface 
  231.      * @throws ContainerExceptionInterface 
  232.      */
  233.     #[Route(
  234.         '/formations_partenaires/{subpath}',
  235.         name: 'formation-partenaire',
  236.         methods: ['GET', 'HEAD', 'POST'],
  237.         requirements: ['subpath' => ".+$"],
  238.     )]
  240.     public function formationPartenaire(Request $request, HtmlSanitizerInterface $sanitizer): Response
  241.     {
  242.         $subpath = $request->attributes->get('_route_params')["subpath"];
  244.         // initialize l'object RouteController 
  245.         // defini les constantes avec un fichier de config en option
  246.         $this->init(); // $this->init("/private/Config.php");
  248.         // Redirection
  249.         Redirection::verifHost();
  251.         /* === la logique propre à ce groupe de routes === */
  252.         // on ajoute un controller au controller /path/Controller.php
  253.         if ($subpath === "detail")
  254.             $this->setController('/formations_partenaires/detail/Controller.php');
  255.         else
  256.             $this->setController('/formations_partenaires/formation/Controller.php');
  257.         /* === la logique propre à ce groupe de routes === */
  259.         // On renvoie le résultat
  260.         return new Response($this->getResponse(), $this->getStatus());
  261.     }
  264.     /**
  265.      * @param Request $request 
  266.      * @return Response 
  267.      * @throws LogicException 
  268.      * @throws NotFoundExceptionInterface 
  269.      * @throws ContainerExceptionInterface 
  270.      */
  271.     #[Route(
  272.         '/{subpath}',
  273.         name: 'all',
  274.         methods: ['GET', 'HEAD', 'POST'],
  275.         requirements: ['subpath' => ".*"],
  276.     )]
  278.     public function all(Request $request, HtmlSanitizerInterface $sanitizer): Response
  279.     {
  281.         // initialize l'object RouteController 
  282.         // defini les constantes avec un fichier de config en option
  283.         $this->init(); // $this->init("/private/Config.php");
  285.         // Redirection
  286.         Redirection::verifHost();
  288.         /* === la logique propre à ce groupe de routes === */
  289.         // on ajoute un controller au controller /path/Controller.php
  290.         //$this->setController('/page/Controller.php');
  291.         /* === la logique propre à ce groupe de routes === */
  293.         // On renvoie le résultat
  294.         return new Response($this->getResponse(), $this->getStatus());
  295.     }
  299.     /**
  300.      * Routes::notFound(Controller) défini le comportement du site en cas de d'erreur 404
  301.      * on peut renvoyer certaines infos, choisir d'inclure un Template404.twig spécifique, ou inclure une ogique pour des 404 différenciés
  302.      * on renvoyer en général un $CONTROLLER->setTemplate(string) (on peut ajouter des variables twig $CONTROLLER->setTwig(array)) et un $CONTROLLER->setStatus(404)
  303.      * Mais on peut aussi renvoyer un $CONTROLLER->setResponse(string) pour certaines routes de type API
  304.      *
  305.      * @param Controller $CONTROLLER
  306.      * @return void
  307.      */
  308.     public static function notFound(Controller &$CONTROLLER)
  309.     {
  310.         $CONTROLLER->setStatus(404);
  311.         if (str_contains(__URL__, "/formations/") || str_contains(__URL__, "/formations_partenaires/"))
  312.             $CONTROLLER->setTemplate('/404formation.twig');
  313.         else
  314.             $CONTROLLER->setTemplate('/404.twig');
  315.     }
  316. }