src/Controller/HomeController.php line 322

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\DepotFichier;
  6. use App\Form\DepotFichierRegionType;
  7. use App\Form\DepotFichierDeptType;
  8. use App\Form\DepotFichierEpciType;
  9. use App\Form\DepotFichierComType;
  10. use App\Model\HelperModel;
  11. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  12. use Symfony\Component\HttpFoundation\Response;
  13. use Symfony\Component\HttpFoundation\JsonResponse;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\Routing\Annotation\Route;
  16. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  17. use Symfony\Component\HttpFoundation\RequestStack;
  18. use Doctrine\ORM\EntityManager;
  19. use Doctrine\Persistence\ManagerRegistry as PersistenceManagerRegistry;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Component\Notifier\ChatterInterface;
  22. use Symfony\Component\DependencyInjection\ParameterBag\ContainerBagInterface;
  23. use Symfony\Component\Serializer\SerializerInterface;
  24. use Twig\Environment;
  25. use Symfony\Component\String\Slugger\SluggerInterface;
  27. class HomeController extends AbstractController
  28. {
  30.     protected $loader;
  32.     public function __construct(Environment $twig)
  33.     {
  34.         $this->loader = $twig->getLoader();
  35.     }
  37.     #[Route('/', name: 'home')]
  38.     public function index(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  39.     {        
  40.         return $this->render('index.html.twig');
  41.     }
  43.     #[Route('/depot-fichier-region', name: 'depot_fichier_region')]
  44.     public function depotFichierRegion(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  45.     {
  46.         $depotFichier = new DepotFichier();
  48.         $form = $this->createForm(DepotFichierRegionType::class, $depotFichier, [
  49.             'attr' => array(
  50.                 'id' => 'form-create',
  51.                 'novalidate' => 'novalidate',
  52.                 'class' => 'parsley-examples'
  53.             ),
  54.             'allow_extra_fields' => true,
  55.             'action' => $this->generateUrl('depot_success_region'),
  56.         ]);
  59.         $form->handleRequest($request);
  60.         /*if ($form->isSubmitted() && $form->isValid()) {
  61.             $depotFichier = $form->getData();
  62.             dd($request);
  63.         }*/
  65.         return $this->render('depot_fichier_region.html.twig', [
  66.             'form' => $form->createView(),
  67.         ]);
  68.     }
  70.     #[Route('/depot-success-region', name: 'depot_success_region')]
  71.     public function depotSuccessRegion(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  72.     {
  73.         $depotFichier = new DepotFichier();
  75.         $form = $this->createForm(DepotFichierRegionType::class, $depotFichier, [
  76.             'attr' => array(
  77.                 'id' => 'form-create',
  78.                 'novalidate' => 'novalidate',
  79.             ),
  80.             'allow_extra_fields' => true,
  81.             'action' => $this->generateUrl('depot_success_region'),
  82.         ]);
  83.         $form->handleRequest($request);
  84.         if ($form->isSubmitted()) {
  85.             $depotFichier = $form->getData();
  86.             if($depotFichier->getIdentifiantCollectivite() == null){
  87.                 $idCollectivite = '94';
  88.             }else{
  89.                 $idCollectivite = $depotFichier->getIdentifiantCollectivite();
  90.             }
  92.             $repository = $entityManager->getRepository(DepotFichier::class);
  93.             $depotFichierRes = $repository->findOneBy(['identifiantCollectivite' => $idCollectivite],array('dateDepot' => 'DESC'));
  94.             return $this->render('depot_success.html.twig',[
  95.                 'depotFichier' => $depotFichierRes
  96.             ]);   
  97.         }        
  98.     }
  100.     #[Route('/depot-success-dept', name: 'depot_success_dept')]
  101.     public function depotSuccessDept(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  102.     {
  103.         $depotFichier = new DepotFichier();
  105.         $form = $this->createForm(DepotFichierDeptType::class, $depotFichier, [
  106.             'attr' => array(
  107.                 'id' => 'form-create',
  108.                 'novalidate' => 'novalidate',
  109.             ),
  110.             'allow_extra_fields' => true,
  111.             'action' => $this->generateUrl('depot_success_dept'),
  112.         ]);
  113.         $form->handleRequest($request);
  114.         if ($form->isSubmitted()) {
  115.             $depotFichier = $form->getData();
  116.             if($depotFichier->getIdentifiantCollectivite() == null){
  117.                 $idCollectivite = '94';
  118.             }else{
  119.                 $idCollectivite = $depotFichier->getIdentifiantCollectivite();
  120.             }
  122.             $repository = $entityManager->getRepository(DepotFichier::class);
  123.             $depotFichierRes = $repository->findOneBy(['identifiantCollectivite' => $idCollectivite],array('dateDepot' => 'DESC'));
  124.             return $this->render('depot_success.html.twig',[
  125.                 'depotFichier' => $depotFichierRes
  126.             ]);   
  127.         }        
  128.     }
  130.     #[Route('/depot-success-epci', name: 'depot_success_epci')]
  131.     public function depotSuccessEpci(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  132.     {
  133.         $depotFichier = new DepotFichier();
  135.         $form = $this->createForm(DepotFichierEpciType::class, $depotFichier, [
  136.             'attr' => array(
  137.                 'id' => 'form-create',
  138.                 'novalidate' => 'novalidate',
  139.             ),
  140.             'allow_extra_fields' => true,
  141.             'action' => $this->generateUrl('depot_success_epci'),
  142.         ]);
  143.         $form->handleRequest($request);
  144.         if ($form->isSubmitted()) {
  145.             $depotFichier = $form->getData();
  146.             if($depotFichier->getIdentifiantCollectivite() == null){
  147.                 $idCollectivite = '94';
  148.             }else{
  149.                 $idCollectivite = $depotFichier->getIdentifiantCollectivite();
  150.             }
  152.             $repository = $entityManager->getRepository(DepotFichier::class);
  153.             $depotFichierRes = $repository->findOneBy(['identifiantCollectivite' => $idCollectivite],array('dateDepot' => 'DESC'));
  154.             return $this->render('depot_success.html.twig',[
  155.                 'depotFichier' => $depotFichierRes
  156.             ]);   
  157.         }        
  158.     }
  160.     #[Route('/depot-success-com', name: 'depot_success_com')]
  161.     public function depotSuccessCom(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  162.     {
  163.         $depotFichier = new DepotFichier();
  165.         $form = $this->createForm(DepotFichierComType::class, $depotFichier, [
  166.             'attr' => array(
  167.                 'id' => 'form-create',
  168.                 'novalidate' => 'novalidate',
  169.             ),
  170.             'allow_extra_fields' => true,
  171.             'action' => $this->generateUrl('depot_success_com'),
  172.         ]);
  173.         $form->handleRequest($request);
  174.         if ($form->isSubmitted()) {
  175.             $depotFichier = $form->getData();
  176.             if($depotFichier->getIdentifiantCollectivite() == null){
  177.                 $idCollectivite = '94';
  178.             }else{
  179.                 $idCollectivite = $depotFichier->getIdentifiantCollectivite();
  180.             }
  182.             $repository = $entityManager->getRepository(DepotFichier::class);
  183.             $depotFichierRes = $repository->findOneBy(['identifiantCollectivite' => $idCollectivite],array('dateDepot' => 'DESC'));
  184.             return $this->render('depot_success.html.twig',[
  185.                 'depotFichier' => $depotFichierRes
  186.             ]);   
  187.         }        
  188.     }
  190.     #[Route('/upload-fichier-region', name: 'upload_fichier_region')]
  191.     public function uploadFichierRegion(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger, HelperModel $helperModel): JsonResponse
  192.     {
  193.         $myfile = $request->files->get('file');
  194.         // this condition is needed because the 'brochure' field is not required
  195.         // so the PDF file must be processed only when a file is uploaded
  196.         if ($myfile) {
  197.             $originalFilename = pathinfo($myfile->getClientOriginalName(), PATHINFO_FILENAME);
  198.             // this is needed to safely include the file name as part of the URL
  199.             $safeFilename = 'reg-94-corse-'.time();
  201.             $newFilename = $safeFilename.'.'.$myfile->guessExtension();
  203.             // Move the file to the directory where brochures are stored
  204.             try {
  205.                 $helperModel->addUnimportedDocumentAzure("fichiers/", $myfile, $newFilename);
  206.                 $myfile->move(
  207.                     $this->getParameter('upload_directory'),
  208.                     $newFilename
  209.                 );
  210.                 $depotFichier = new Depotfichier();
  211.                 $depotFichier->setPrenom($request->get('prenom'));
  212.                 $depotFichier->setNom($request->get('nom'));
  213.                 $depotFichier->setFonction($request->get('fonction'));
  214.                 $depotFichier->setEmail($request->get('email'));
  215.                 $depotFichier->setTelephone($request->get('telephone'));
  216.                 $depotFichier->setTypeCollectivite('region');
  217.                 $depotFichier->setIdentifiantCollectivite('94');
  218.                 $depotFichier->setIp($request->getClientIp());
  219.                 $depotFichier->setDateDepot(new \DateTimeImmutable("now"));
  220.                 $depotFichier->setFichier($newFilename);
  221.                 $depotFichier->setOriginalFilename($myfile->getClientOriginalName());
  223.                 $entityManager->persist($depotFichier);
  224.                 $entityManager->flush();
  225.                 return $this->json($depotFichier->getId(), $status = 200, $headers = [], $context = []);
  226.             } catch (FileException $e) {
  227.                 return $this->json($e, $status = 500, $headers = [], $context = []);
  228.             }
  229.             
  230.         }
  231.     }
  233.     #[Route('/check-region-exist/{depotFichier}', name: 'check_region_exist')]
  234.     public function checkFichierRegion(DepotFichier $depotFichier, EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger, HelperModel $helperModel): bool
  235.     {
  236.         $repository = $entityManager->getRepository(DepotFichier::class);
  237.         $depotFichierRes = $repository->findOneBy(['id' => $depotFichier]);
  238.         if($depotFichierRes != null){
  239.             return true;
  240.         }else{
  241.             return false;
  242.         }
  243.     }
  246.     #[Route('/depot-fichier-dept', name: 'depot_fichier_dept')]
  247.     public function depotFichierDept(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  248.     {
  249.         $depotFichier = new DepotFichier();
  251.         $form = $this->createForm(DepotFichierDeptType::class, $depotFichier, [
  252.             'attr' => array(
  253.                 'id' => 'form-create',
  254.                 'novalidate' => 'novalidate',
  255.                 'class' => 'parsley-form-dept'
  256.             ),
  257.             'action' => $this->generateUrl('depot_success_dept'),
  258.         ]);
  260.         return $this->render('depot_fichier_dept.html.twig', [
  261.             'form' => $form->createView(),
  262.         ]);
  263.     }
  265.     #[Route('/upload-fichier-dept', name: 'upload_fichier_dept')]
  266.     public function uploadFichierDept(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger, HelperModel $helperModel): JsonResponse
  267.     {
  268.         $myfile = $request->files->get('file');
  269.         // this condition is needed because the 'brochure' field is not required
  270.         // so the PDF file must be processed only when a file is uploaded
  271.         if ($myfile) {
  272.             $originalFilename = pathinfo($myfile->getClientOriginalName(), PATHINFO_FILENAME);
  273.             // this is needed to safely include the file name as part of the URL
  274.             $safeFilename = 'dept-'.$request->get('identifiantCollectivite').'-'.time();
  276.             $newFilename = $safeFilename.'.'.$myfile->guessExtension();
  278.             // Move the file to the directory where brochures are stored
  279.             try {
  280.                 $helperModel->addUnimportedDocumentAzure("fichiers/", $myfile, $newFilename);
  281.                 $myfile->move(
  282.                     $this->getParameter('upload_directory'),
  283.                     $newFilename
  284.                 );
  285.                 $depotFichier = new Depotfichier();
  286.                 $depotFichier->setPrenom($request->get('prenom'));
  287.                 $depotFichier->setNom($request->get('nom'));
  288.                 $depotFichier->setFonction($request->get('fonction'));
  289.                 $depotFichier->setEmail($request->get('email'));
  290.                 $depotFichier->setTelephone($request->get('telephone'));
  291.                 $depotFichier->setTypeCollectivite('dept');
  292.                 $depotFichier->setIdentifiantCollectivite($request->get('identifiantCollectivite'));
  293.                 $depotFichier->setIp($request->getClientIp());
  294.                 $depotFichier->setDateDepot(new \DateTimeImmutable("now"));
  295.                 $depotFichier->setFichier($newFilename);
  296.                 $depotFichier->setOriginalFilename($myfile->getClientOriginalName());
  298.                 $entityManager->persist($depotFichier);
  299.                 $entityManager->flush();
  300.                 
  301.             } catch (FileException $e) {
  302.                 return $this->json($e, $status = 500, $headers = [], $context = []);
  303.             }
  304.             return $this->json('success', $status = 200, $headers = [], $context = []);
  305.         }
  306.     }
  308.     #[Route('/check-exist/{depotFichier}', name: 'check_exist')]
  309.     public function checkDepotExist($depotFichier, EntityManagerInterface $entityManager): JsonResponse
  310.     {
  311.         $repository = $entityManager->getRepository(DepotFichier::class);
  312.         $depotFichierRes = $repository->findOneBy(['identifiantCollectivite' => $depotFichier],['dateDepot' => 'DESC']);
  314.         if($depotFichierRes != null){
  315.             return $this->json($depotFichierRes, $status = 200, $headers = [], $context = []);
  316.         }else{
  317.             return $this->json('not-exist', $status = 200, $headers = [], $context = []);
  318.         }
  319.     }
  321.     #[Route('/depot-fichier-epci', name: 'depot_fichier_epci')]
  322.     public function depotFichierEpci(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  323.     {
  324.         $depotFichier = new DepotFichier();
  326.         $form = $this->createForm(DepotFichierEpciType::class, $depotFichier, [
  327.             'attr' => array(
  328.                 'id' => 'form-create',
  329.                 'novalidate' => 'novalidate',
  330.                 'class' => 'parsley-examples'
  331.             ),
  332.             'action' => $this->generateUrl('depot_success_epci'),
  333.         ]);
  335.         return $this->render('depot_fichier_epci.html.twig', [
  336.             'form' => $form->createView(),
  337.         ]);
  338.     }
  340.     #[Route('/upload-fichier-epci', name: 'upload_fichier_epci')]
  341.     public function uploadFichierEpci(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger, HelperModel $helperModel): JsonResponse
  342.     {
  343.         $myfile = $request->files->get('file');
  344.         // this condition is needed because the 'brochure' field is not required
  345.         // so the PDF file must be processed only when a file is uploaded
  346.         if ($myfile) {
  347.             $originalFilename = pathinfo($myfile->getClientOriginalName(), PATHINFO_FILENAME);
  348.             // this is needed to safely include the file name as part of the URL
  349.             $safeFilename = 'epci-'.$request->get('identifiantCollectivite').'-'.time();
  351.             $newFilename = $safeFilename.'.'.$myfile->guessExtension();
  353.             // Move the file to the directory where brochures are stored
  354.             try {
  355.                 $helperModel->addUnimportedDocumentAzure("fichiers/", $myfile, $newFilename);
  356.                 $myfile->move(
  357.                     $this->getParameter('upload_directory'),
  358.                     $newFilename
  359.                 );
  360.                 $depotFichier = new Depotfichier();
  361.                 $depotFichier->setPrenom($request->get('prenom'));
  362.                 $depotFichier->setNom($request->get('nom'));
  363.                 $depotFichier->setFonction($request->get('fonction'));
  364.                 $depotFichier->setEmail($request->get('email'));
  365.                 $depotFichier->setTelephone($request->get('telephone'));
  366.                 $depotFichier->setTypeCollectivite('epci');
  367.                 $depotFichier->setIdentifiantCollectivite($request->get('identifiantCollectivite'));
  368.                 $depotFichier->setIp($request->getClientIp());
  369.                 $depotFichier->setDateDepot(new \DateTimeImmutable("now"));
  370.                 $depotFichier->setFichier($newFilename);
  371.                 $depotFichier->setOriginalFilename($myfile->getClientOriginalName());
  373.                 $entityManager->persist($depotFichier);
  374.                 $entityManager->flush();
  375.                 
  376.             } catch (FileException $e) {
  377.                 return $this->json($e, $status = 500, $headers = [], $context = []);
  378.             }
  379.             return $this->json('success', $status = 200, $headers = [], $context = []);
  380.         }
  381.     }
  383.     #[Route('/depot-fichier-commune', name: 'depot_fichier_com')]
  384.     public function depotFichierCommune(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger): Response
  385.     {
  386.         $depotFichier = new DepotFichier();
  388.         $form = $this->createForm(DepotFichierComType::class, $depotFichier, [
  389.             'attr' => array(
  390.                 'id' => 'form-create',
  391.                 'novalidate' => 'novalidate',
  392.             ),
  393.             'action' => $this->generateUrl('depot_success_com'),
  394.         ]);
  398.         return $this->render('depot_fichier_com.html.twig', [
  399.             'form' => $form->createView(),
  400.         ]);
  401.     }
  403.     #[Route('/upload-fichier-com', name: 'upload_fichier_com')]
  404.     public function uploadFichierCom(EntityManagerInterface $entityManager, Request $request, SluggerInterface $slugger, HelperModel $helperModel): JsonResponse
  405.     {
  406.         $myfile = $request->files->get('file');
  407.         // this condition is needed because the 'brochure' field is not required
  408.         // so the PDF file must be processed only when a file is uploaded
  409.         if ($myfile) {
  410.             $originalFilename = pathinfo($myfile->getClientOriginalName(), PATHINFO_FILENAME);
  411.             // this is needed to safely include the file name as part of the URL
  412.             $safeFilename = 'com-'.$request->get('identifiantCollectivite').'-'.time();
  414.             $newFilename = $safeFilename.'.'.$myfile->guessExtension();
  416.             // Move the file to the directory where brochures are stored
  417.             try {
  418.                 $helperModel->addUnimportedDocumentAzure("fichiers/", $myfile, $newFilename);
  419.                 $myfile->move(
  420.                     $this->getParameter('upload_directory'),
  421.                     $newFilename
  422.                 );
  423.                 $depotFichier = new Depotfichier();
  424.                 $depotFichier->setPrenom($request->get('prenom'));
  425.                 $depotFichier->setNom($request->get('nom'));
  426.                 $depotFichier->setFonction($request->get('fonction'));
  427.                 $depotFichier->setEmail($request->get('email'));
  428.                 $depotFichier->setTelephone($request->get('telephone'));
  429.                 $depotFichier->setTypeCollectivite('com');
  430.                 $depotFichier->setIdentifiantCollectivite($request->get('identifiantCollectivite'));
  431.                 $depotFichier->setIp($request->getClientIp());
  432.                 $depotFichier->setDateDepot(new \DateTimeImmutable("now"));
  433.                 $depotFichier->setFichier($newFilename);
  434.                 $depotFichier->setOriginalFilename($myfile->getClientOriginalName());
  436.                 $entityManager->persist($depotFichier);
  437.                 $entityManager->flush();
  438.                 
  439.             } catch (FileException $e) {
  440.                 return $this->json($e, $status = 500, $headers = [], $context = []);
  441.             }
  442.             return $this->json('success', $status = 200, $headers = [], $context = []);
  443.         }
  444.     }
  446.     /*#[Route('/{path}')]
  447.     public function root($path)
  448.     {
  449.         if ($this->loader->exists('poubelle/'.$path.'.html.twig')) {
  450.             if ($path == '/' || $path == 'home') {
  451.                 die('Home');
  452.             }
  453.             return $this->render('poubelle/'.$path.'.html.twig');
  454.         }
  455.         throw $this->createNotFoundException();
  456.     }*/
  457. }