src/Controller/HomeController.php line 50

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\User;
  6. use App\Entity\Message;
  7. use App\Entity\Materiel;
  8. use App\Form\CompteType;
  9. use App\Entity\Protocole;
  10. use App\Form\MessageType;
  11. use App\Entity\Commentaire;
  12. use App\Form\CommentaireType;
  13. use Symfony\Component\Mime\Email;
  14. use App\Repository\PageRepository;
  15. use App\Repository\UserRepository;
  16. use App\Repository\SliderRepository;
  17. use App\Repository\ArticleRepository;
  18. use App\Repository\LogPageRepository;
  19. use App\Repository\ContactsRepository;
  20. use App\Repository\MaterielRepository;
  21. use App\Repository\CategorieRepository;
  22. use App\Repository\ProtocoleRepository;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use App\Repository\CommentaireRepository;
  25. use App\Repository\MaterielphotoRepository;
  26. use App\Repository\ProtocolephotoRepository;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\Mailer\MailerInterface;
  29. use Symfony\Component\HttpFoundation\Response;
  30. use Symfony\Component\Routing\Annotation\Route;
  31. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  32. use Symfony\Component\Validator\Constraints\Length;
  34. class HomeController extends AbstractController
  35. {
  37.     /** UTILISATEUR CONNECTE */
  38.     private UserRepository $userRepository;
  39.     public function __construct(UserRepository $userRepository) {
  40.         $this->userRepository = $userRepository;
  41.     }
  42.     private function getUserEntity() : ?User {
  43.         $user = $this->getUser(); 
  44.         if($user == null) return null;           
  45.         $email = $user->getUserIdentifier();
  46.         return  $this->userRepository->findOneBy(["email" => $email]);
  47.     }
  49.     #[Route('/', name: 'home_page')]
  50.     public function index(PageRepository $pageRepository, 
  51.                           ArticleRepository $articleRepository, 
  52.                           CategorieRepository $categorieRepository,
  53.                           ProtocoleRepository $protocoleRepository,
  54.                           SliderRepository $sliderRepository,
  55.                           LogPageRepository $logPageRepository): Response
  56.     {
  57.         $page1 = $pageRepository->findOneBy([ 'url' => 'pourquoi-nos-protocoles']);
  58.         $page2 = $pageRepository->findOneBy([ 'url' => 'organisation-du-cabinet']);
  59.         $page3 = $pageRepository->findOneBy([ 'url' => 'la-bonne-selection-du-materiel']);        
  61.         $articles = $articleRepository->findBy([], ['dtpubli' => 'desc'], 4);        
  63.         $categories = $categorieRepository->findOneBy(['titre' => 'Protocoles'])->getCategories(); 
  64.         $protocoles = $protocoleRepository->findBy(['favori' => '1'], ['titre' => 'asc']); 
  66.         
  67.         $logPageRepository->addLog("accueil", "/", $this->getUser());
  68.         return $this->render('home/index.html.twig', [   
  69.             'page1'=> $page1,
  70.             'page2'=> $page2,
  71.             'page3'=> $page3,
  72.             'articles'=> $articles,
  73.             'categories'=> $categories,
  74.             'protocoles'=> $protocoles,
  75.             'sliders' => $sliderRepository->findAll(),
  76.         ]);
  77.     }
  79.     #[Route('/sousmenus/{code}', name: 'sousmenus_menu')]
  80.     public function getsousmenus($code, CategorieRepository $categorieRepository): Response
  81.     {
  82.         switch($code) {
  84.             case 'protocoles':
  85.                 return $this->render('menu/sousmenus.html.twig', [
  86.                     'categorie' => $categorieRepository->findOneBy(['titre' => 'Protocoles']),
  87.                     'type' => 1,
  88.                 ]);
  90.             case 'materiels':
  91.                 return $this->render('menu/sousmenus.html.twig', [
  92.                     'categorie' => $categorieRepository->findOneBy(['titre' => 'Matériels']),
  93.                     'type' => 2,
  94.                 ]);
  96.             default :
  97.                 return new Response('');
  98.         }        
  99.     }
  101.     /***********************************************************************************************
  102.      * PAGES STATIQUES, ARTICLE et CONTACTS
  103.      */
  105.     #[Route('/page/{url}', name: 'static_page')]
  106.     public function staticpage($url, PageRepository $pageRepository, LogPageRepository $logPageRepository): Response
  107.     {
  108.         $page = $pageRepository->findOneBy([ 'url' => $url]);
  110.         if($page == null) {
  111.             return $this->redirectToRoute('home_page');
  112.         }
  114.         $logPageRepository->addLog($url, "/page/".$url, $this->getUser());
  115.         return $this->render('home/pagestatic.html.twig', [ 
  116.             'page'=> $page
  117.         ]);
  118.     }
  120.     #[Route("/articles", name:"articles_page")]
  121.     public function articlespage(ArticleRepository $articleRepository, LogPageRepository $logPageRepository): Response
  122.     {
  123.         $articles = $articleRepository->findBy([], [ 'dtpubli' => 'desc']);
  124.         return $this->render('home/pagearticles.html.twig', [ 
  125.             'articles'=> $articles
  126.         ]);
  127.     }
  128.     
  129.     #[Route("/article/{url}", name:"article_page")]
  130.     public function articlepage($url, ArticleRepository $articleRepository, LogPageRepository $logPageRepository): Response
  131.     {
  132.         $article = $articleRepository->findOneBy([ 'url' => $url]);
  134.         if($article == null) {
  135.             return $this->redirectToRoute('home_page');            
  136.         }
  138.         $logPageRepository->addLog($url, "/article/".$url, $this->getUser());
  139.         return $this->render('home/pagearticle.html.twig', [ 
  140.             'article'=> $article
  141.         ]);        
  142.     }
  144.     #[Route("/contacts", name:"contacts_page")]
  145.     public function contactspage(Request $request, MailerInterface $mailer, 
  146.                                  ContactsRepository $contactsRepository,
  147.                                  LogPageRepository $logPageRepository,
  148.                                  EntityManagerInterface $entityManager): Response
  149.     {
  150.         //les infos 
  151.         $contactmessage = $contactsRepository->findOneBy(['type' => 'message']);
  152.         $liens = $contactsRepository->findBy(['type' => 'lien']);
  153.         $admins = $contactsRepository->findBy(['type' => 'admin']);
  154.         
  155.         //le message 
  156.         $message = new Message(); 
  157.         $form = $this->createForm(MessageType::class, $message);
  158.         $msgretour ="";
  159.     
  160.         $form->handleRequest($request);     
  161.         if($form->isSubmitted() && $form->isValid()){
  163.             $message = $form->getData();
  164.             $entityManager->persist($message);
  165.             $entityManager->flush();
  167.             //envoi de l'email
  168.             $body = 'Message de '.$message->getNom().' <br/>Email : '.$message->getEmail().' <br/>'.$message->getMessage();
  169.             //$adresse = $contactmessage->getAdresse();
  170.             $adresse = "nadine@aesisoft.fr";
  171.             $email = (new Email())
  172.             ->from('website@lodeao.com')
  173.             ->to($adresse)
  174.             ->subject('LODEAO : '.$message->getObjet())
  175.             ->text($body)
  176.             ->html($body);
  177.             $mailer->send($email);       
  179.             $msgretour ="Votre message a été envoyé. Merci.";
  180.             
  181.             //reset du message
  182.             $message = new Message(); 
  183.             $form = $this->createForm(MessageType::class, $message);
  184.         }
  186.         $logPageRepository->addLog("contacts", "/contacts", $this->getUser());
  187.         return $this->render('home/contacts.html.twig', [
  188.             'form' => $form->createView(),
  189.             'contactmessage' => $contactmessage,
  190.             'msgretour' => $msgretour,
  191.             'liens' => $liens,
  192.             'admins' => $admins,
  193.         ]);
  194.     }
  197.     /***********************************************************************************************
  198.      * CATEGORIE, URGENCES, MATERIEL et PROTOCOLE
  199.      */
  202.     #[Route("/categoriefiltre/{type}/{code}/{coche}", name:"categoriefiltre_page", defaults: ["code"=> "", "coche"=> ""])]
  203.     public function categoriefiltrepage($type, $code, $coche,
  204.                                         ProtocoleRepository $protocoleRepository, 
  205.                                         MaterielRepository $materielRepository, 
  206.                                         CategorieRepository $categorieRepository,
  207.                                         ProtocolephotoRepository $protocolephotoRepository,
  208.                                         MaterielphotoRepository $materielphotoRepository,
  209.                                         LogPageRepository $logPageRepository): Response
  210.     {        
  211.         $titre="";
  212.         $soustitre="";
  213.         $description="";
  214.         $protocoles = [];
  215.         $photos = [];
  216.         $materiels = [];
  217.         $sscategories = [];
  218.         $parentid=0;
  220.         if($code=='U') $code=34;
  221.                 
  222.         if($type == 1) {
  223.             $titre="Protocoles";
  224.             if(is_numeric($code) && $code != '1') {
  225.                 $catid = intval($code);
  226.                 $categfiltre = $categorieRepository->find($catid);    
  227.                 if($categfiltre != null &&$categfiltre->getParent() != null) {
  228.                     $parentid=$categfiltre->getParent()->getId();
  229.                     if($parentid >2 ) {
  230.                         $parentid=$categfiltre->getParent()->getParent()->getId(); 
  231.                         if($parentid <3 ) { $parentid=$categfiltre->getParent()->getId(); }
  232.                     }   
  233.                 }                        
  234.                 $soustitre =$categfiltre->getTitre();     
  235.                 $description = $categfiltre->getDescription();                             
  236.                 $protocoles = $protocoleRepository->findByCategorie($categfiltre);
  237.                 $sscategories = $categorieRepository->findBy(['parent' => $catid],['titre' => 'asc']);
  238.                 // if(count($sscategories) >0 ){
  239.                 //     foreach($sscategories as $sscatg){
  240.                 //         $temp = $protocoleRepository->findByCategorie($sscatg);
  241.                 //         if(count($temp)) $protocoles = array_merge($protocoles, $temp);
  242.                 //     }
  243.                 // }                                
  244.             }
  245.             else {
  246.                 //Catégorie racine Protocoles
  247.                 $protocoles = $protocoleRepository->findBy([],['titre' => 'asc']);
  248.                 $categfiltre = $categorieRepository->find(1);       
  249.                 $description = $categfiltre->getDescription(); 
  250.             }      
  251.             //recup des photos
  252.             foreach($protocoles as $p){
  253.                 $photo = $protocolephotoRepository->findOneBy(['protocole' => $p], ['ordre' => 'asc']);
  254.                 if($photo != null ){
  255.                     $photos[$p->getId()] = $photo->getImage()->getUrlfichier();
  256.                 }
  257.                 else {
  258.                     $photos[$p->getId()] = null;
  259.                 }
  260.             } 
  261.         }
  262.         else {
  263.             $titre="Matériels";
  264.             if(is_numeric($code) && $code > 1) {
  265.                 $catid = intval($code);
  266.                 $categfiltre = $categorieRepository->find($catid);  
  267.                 if($categfiltre->getParent() != null) {
  268.                     $parentid=$categfiltre->getParent()->getId();
  269.                     if($parentid >2 ) {
  270.                         $parentid=$categfiltre->getParent()->getParent()->getId(); 
  271.                         if($parentid <3 ) { $parentid=$categfiltre->getParent()->getId(); }
  272.                     } 
  273.                 }                          
  274.                 $soustitre =$categfiltre->getTitre();      
  275.                 $description = $categfiltre->getDescription();
  276.                 $materiels = $materielRepository->findByCategorie($categfiltre, $coche);
  277.                 $sscategories = $categorieRepository->findBy(['parent' => $catid],['titre' => 'asc']);
  278.                 // if(count($sscategories) >0 ){
  279.                 //     foreach($sscategories as $sscatg){
  280.                 //         $temp = $protocoleRepository->findByCategorie($sscatg);
  281.                 //         if(count($temp)) $materiels = array_merge($materiels, $temp);
  282.                 //     }
  283.                 // }
  284.             }
  285.             else{
  286.                 switch($coche) {
  287.                     case 'S':
  288.                         $materiels = $materielRepository->findBy(['codeSC' => $coche, 'archive' => false],['nom' => 'asc']);
  289.                         $titre="Matériels";
  290.                         $soustitre ="Matériels stérilisables";
  291.                         break;
  292.                     case 'C':
  293.                         $materiels = $materielRepository->findBy(['codeSC' => $coche, 'archive' => false],['nom' => 'asc']);
  294.                         $titre="Matériels";
  295.                         $soustitre ="Matériels consommables";
  296.                         break;
  297.                     case 'E':
  298.                         $materiels = $materielRepository->findBy(['codeSC' => $coche, 'archive' => false],['nom' => 'asc']);
  299.                         $titre="Matériels";
  300.                         $soustitre ="Equipements";
  301.                         break;
  302.                     case 'P':
  303.                         $materiels = $materielRepository->findBy(['codePA' => $coche, 'archive' => false],['nom' => 'asc']);
  304.                         $titre="Matériels";
  305.                         $soustitre ="Matériels du plateau Praticien";
  306.                         break;
  307.                     case 'A':
  308.                         $materiels = $materielRepository->findBy(['codePA' => $coche, 'archive' => false],['nom' => 'asc']);
  309.                         $titre="Matériels";
  310.                         $soustitre ="Matériels du plateau Assistante";
  311.                         break;
  312.                     
  313.                     default :
  314.                         //Catégorie racine Materiels
  315.                         $materiels = $materielRepository->findBy([],['nom' => 'asc']);
  316.                         $categfiltre = $categorieRepository->find(2);       
  317.                         $description = $categfiltre->getDescription(); 
  318.                 }
  319.             }
  320.              //recup des photos
  321.              foreach($materiels as $p){
  322.                 $photo = $materielphotoRepository->findOneBy(['materiel' => $p], ['ordre' => 'asc']);
  323.                 if($photo != null ){
  324.                     $photos[$p->getId()] = $photo->getImage()->getUrlfichier();
  325.                 }
  326.                 else {
  327.                     $photos[$p->getId()] = null;
  328.                 }
  329.             } 
  330.         }
  331.                
  333.         $logPageRepository->addLog($titre." ".$soustitre, "/categoriefiltre/".$type."/".$code, $this->getUser());
  334.         return $this->render('home/pagecategories.html.twig', [ 
  335.             'type' => $type,
  336.             'titre' => $titre,
  337.             'materiels'=> $materiels,
  338.             'protocoles'=> $protocoles,
  339.             'soustitre' => $soustitre,
  340.             'description' => $description,
  341.             'code' => $code,
  342.             'coche' => $coche,
  343.             'categorie' => $categorieRepository->find($type),
  344.             'sscategories' => $sscategories,
  345.             'parentid' => $parentid,
  346.             'photos' => $photos,
  347.         ]);
  348.     }
  350.     #[Route("/categoriefiltrenom/{type}/{nom}", name:"categoriefiltrenom_page")]
  351.     public function categoriefiltrepagenom($type, $nom, CategorieRepository $categorieRepository): Response
  352.     {   
  353.         $nom = str_replace("%27","'",$nom); 
  354.         $nom = str_replace("%20"," ",$nom); 
  355.         $nom = trim($nom); //dd($nom);
  356.         $categfiltre = $categorieRepository->getCategoriesParNom($nom,$type); //dd($categfiltre);
  358.         $id = 1;
  359.         if($categfiltre != null ) $id=$categfiltre->getId();
  360.         if($id == 2) $id = 1; //cas matériels !!
  361.         
  362.         return $this->redirectToRoute('categoriefiltre_page', ['code' => $id, 'type' => $type]);  
  363.     }
  366.     #[Route("/protocole/{id}/{nom}", name:"protocole_page", defaults: ["nom"=> ""])]
  367.     public function protocolepage(Protocole $protocole, Request $request, 
  368.                                   LogPageRepository $logPageRepository, 
  369.                                   CommentaireRepository $commentaireRepository,
  370.                                   ProtocolephotoRepository $protocolephotoRepository,
  371.                                   EntityManagerInterface $entityManager): Response
  372.     {        
  373.         if($protocole->getArchive()) {
  374.             return $this->redirectToRoute('home_page');
  375.         }
  377.         $isFavori = false;
  378.         $usermateriels = [];
  380.         //force le user courant par sécurité ;-)
  381.         $user = $this->getUserEntity();        
  382.   
  383.         //formulaire nouveau commentaire
  384.         $commentaire = new Commentaire();        
  385.         $form = $this->createForm(CommentaireType::class, $commentaire);
  386.         $form->handleRequest($request);
  387.         if ($form->isSubmitted() && $form->isValid() && $user != null) {
  388.             $commentaire->setDatepubli(new \DateTime());
  389.             $commentaire->setValide(true);
  390.             $commentaire->setProtocole($protocole);
  391.             $commentaire->setAuteur($user);
  392.             $entityManager->persist($commentaire);
  393.             $entityManager->flush();
  394.             //redirection pour nouveau formulaire !
  395.             return $this->redirectToRoute('protocole_page', ['id' => $protocole->getId(), 'nom' => $protocole->getTitre()]);     
  396.         }
  398.         if($user != null){
  399.             //protocole dans les favoris ?
  400.             foreach($user->getProtocoles() as $prot){
  401.                 if($prot->getId() == $protocole->getId()) {
  402.                     $isFavori = true;
  403.                     break;
  404.                 }
  405.             }        
  406.             //materiels    
  407.             foreach($user->getMateriels() as $matos){
  408.                 $usermateriels[]=$matos->getId();
  409.             }  
  410.         }
  412.         //url catégories complete
  413.         $urls=[];
  414.         $categories = $protocole->getCategories();
  415.         if($categories->count()>0) {
  416.             $categorie = $categories[0]; //dd($categorie);
  417.             $urls = $this->getCategoriesParentes($categorie);           
  418.         }
  420.         $logPageRepository->addLog("Protocole ".$protocole->getTitre(), "/protocole/".$protocole->getId(), $this->getUser());
  421.         return $this->render('home/pageprotocole.html.twig', [ 
  422.             'urls' => $urls,
  423.             'protocole' => $protocole,
  424.             'protocolephotos' => $protocolephotoRepository->findBy(['protocole' => $protocole], ['ordre' => 'asc']),
  425.             'isFavori'  => $isFavori,
  426.             'usermateriels'  => $usermateriels,
  427.             'commentaires'  => $commentaireRepository->findBy(['protocole'=>$protocole], ['datepubli'=>'desc']),
  428.             'form' => $form,
  429.         ]);
  430.     }
  433.     #[Route("/materiel/{id}", name:"materiel_page")]
  434.     public function materielpage(Materiel $materiel, Request $request,
  435.                                  LogPageRepository $logPageRepository,
  436.                                  CommentaireRepository $commentaireRepository,
  437.                                  MaterielphotoRepository $materielphotoRepository,
  438.                                  EntityManagerInterface $entityManager): Response
  439.     {
  440.         if($materiel->isArchive()) {
  441.             return $this->redirectToRoute('home_page');
  442.         }
  444.         //force le user courant par sécurité ;-)
  445.         $user = $this->getUserEntity();        
  447.         //formulaire nouveau commentaire
  448.         $commentaire = new Commentaire();        
  449.         $form = $this->createForm(CommentaireType::class, $commentaire);
  450.         $form->handleRequest($request);
  451.         if ($form->isSubmitted() && $form->isValid() && $user != null) {
  452.             $commentaire->setDatepubli(new \DateTime());
  453.             $commentaire->setValide(true);
  454.             $commentaire->setMateriel($materiel);
  455.             $commentaire->setAuteur($user);
  456.             $entityManager->persist($commentaire);
  457.             $entityManager->flush();
  458.             //redirection pour nouveau formulaire !
  459.             return $this->redirectToRoute('materiel_page', ['id' => $materiel->getId()]);         
  460.         }
  462.         //url catégories complete
  463.         $urls=[];
  464.         $categories = $materiel->getCategories();
  465.         if($categories->count()>0) {
  466.             $categorie = $categories[0]; //dd($categorie);
  467.             $urls = $this->getCategoriesParentes($categorie);           
  468.         }
  470.         //photos ds produits associes
  471.         $assocphotos=[];
  472.         foreach($materiel->getAssocies() as $assoc){
  473.             $assocphotos[$assoc->getId()]=$materielphotoRepository->findBy(['materiel' => $assoc], ['ordre' => 'asc']);
  474.         }
  476.         //favori ?
  477.         $isFavori = false;
  478.         if($user != null){
  479.             //materiel dans les favoris ?
  480.             foreach($user->getMateriels() as $item){
  481.                 if($item->getId() == $materiel->getId()) {
  482.                     $isFavori = true;
  483.                     break;
  484.                 }
  485.             }     
  486.         }
  488.         $logPageRepository->addLog("Matériel ".$materiel->getNom(), "/materiel/".$materiel->getId(), $this->getUser());
  489.         return $this->render('home/pagemateriel.html.twig', [ 
  490.             'materiel'=> $materiel,
  491.             'materielphotos' => $materielphotoRepository->findBy(['materiel' => $materiel], ['ordre' => 'asc']),
  492.             'assocphotos' => $assocphotos,
  493.             'isFavori' => $isFavori,
  494.             'urls' => $urls,
  495.             'commentaires'  => $commentaireRepository->findBy(['materiel'=>$materiel], ['datepubli'=>'desc']),
  496.             'form' => $form,
  497.         ]);
  498.     }
  500.     private function getCategoriesParentes($categorie) {
  501.         $urls=[];
  502.         $urls[] = $categorie->getTitre();
  504.         //parent 1
  505.         $categorie = $categorie->getParent();
  506.         if($categorie == null) return $urls;
  507.         array_unshift($urls, $categorie->getTitre());
  509.         //parent 2
  510.         $categorie = $categorie->getParent();
  511.         if($categorie == null) return $urls;
  512.         array_unshift($urls, $categorie->getTitre());
  513.         
  514.         //parent 3
  515.         $categorie = $categorie->getParent();
  516.         if($categorie == null) return $urls;
  517.         array_unshift($urls, $categorie->getTitre());
  519.         //parent 4
  520.         $categorie = $categorie->getParent();
  521.         if($categorie == null) return $urls;
  522.         array_unshift($urls, $categorie->getTitre());
  524.         //parent 5
  525.         $categorie = $categorie->getParent();
  526.         if($categorie == null) return $urls;
  527.         array_unshift($urls, $categorie->getTitre());
  529.         return $urls;
  530.     }
  533.     /***********************************************************************************************
  534.      * COMPTE
  535.      */
  537.     #[Route("/compte", name:"compte_page")]
  538.     public function comptepage(): Response
  539.     {
  540.         //force le user courant par sécurité ;-)
  541.         $user = $this->getUserEntity();        
  542.         if ($user == null) {
  543.             return $this->redirectToRoute('home_page');
  544.         }
  545.         if ($user->hasRole('ROLE_ADMIN')) {
  546.             return $this->redirectToRoute('admin548637_home');
  547.         }
  548.         else {
  549.             return $this->redirectToRoute('home_page');
  550.         }        
  551.     }
  553.     
  555.     #[Route("/infoscompte", name:"infoscompte_page", methods:["GET","POST"])]
  556.     public function edit(Request $request, LogPageRepository $logPageRepository,
  557.                          ProtocolephotoRepository $protocolephotoRepository ,
  558.                          MaterielphotoRepository $materielphotoRepository,
  559.                          EntityManagerInterface $entityManager): Response
  560.     {
  561.         //force le user courant par sécurité ;-)
  562.         $user = $this->getUserEntity();        
  563.         if ($user == null) {
  564.             return $this->redirectToRoute('home_page');
  565.         }
  567.         $form = $this->createForm(CompteType::class, $user);
  568.         $form->handleRequest($request);
  569.         if ($form->isSubmitted() && $form->isValid()) {
  570.             $entityManager->flush();
  571.             return $this->redirectToRoute('infoscompte_page', [], Response::HTTP_SEE_OTHER);
  572.         }
  574.         //photos des favoris
  575.         $protocolesphotos =[];
  576.         $materielsphotos =[];
  577.         foreach($user->getProtocoles() as $item){
  578.             $photos = $protocolephotoRepository->findBy(['protocole' => $item], ['ordre' => 'asc']);
  579.             if(count($photos) >0) 
  580.                  $protocolesphotos[$item->getId()] = $photos[0];
  581.             else $protocolesphotos[$item->getId()] = null;
  582.         }
  583.         foreach($user->getMateriels() as $item){
  584.             $photos = $materielphotoRepository->findBy(['materiel' => $item], ['ordre' => 'asc']);
  585.             if(count($photos) >0) 
  586.                  $materielsphotos[$item->getId()] = $photos[0];
  587.             else $materielsphotos[$item->getId()] = null;
  588.         }
  590.         
  591.         $logPageRepository->addLog("Mon compte", "/infoscompte/".$user->getId(), $user);
  593.         return $this->render('home/pagecompte.html.twig', [
  594.             'user' => $user,
  595.             'protocolesphotos' => $protocolesphotos,
  596.             'materielsphotos' => $materielsphotos,
  597.             'form' => $form,
  598.         ]);
  599.     }
  602.     #[Route("/addusermaterielajax/{id}", name:"addusermateriel_ajax")]
  603.     public function addusermaterielajax(Materiel $materiel, EntityManagerInterface $entityManager): Response
  604.     {
  605.        //force le user courant par sécurité ;-)
  606.        $user = $this->getUserEntity();        
  607.         if ($user == null) {
  608.             return new Response(false);
  609.         }
  610.         
  611.         //test si existe déjà
  612.         foreach($user->getMateriels() as $usermat){
  613.             if($usermat->getId() == $materiel->getId()) {
  614.                 return new Response(true); //existe déjà
  615.             }
  616.         }
  618.         //sinon l'ajoute
  619.         $user->addMateriel($materiel);
  620.         $entityManager->flush();
  622.         return new Response(true);
  623.     }
  625.     #[Route("/adduserprotocole/{id}", name:"adduserprotocole_ajax")]
  626.     public function adduserprotocole(Protocole $protocole, EntityManagerInterface $entityManager): Response
  627.     {
  628.         //force le user courant par sécurité ;-)
  629.         $user = $this->getUserEntity();        
  630.          if ($user != null) {  
  631.             //test si existe déjà
  632.             foreach($user->getProtocoles() as $userprot){
  633.                 if($userprot->getId() == $protocole->getId()) {
  634.                     return $this->redirectToRoute('protocole_page', ['id' => $protocole->getId(), 'nom' => $protocole->getTitre()]); //existe déjà
  635.                 }
  636.             }
  637.             //sinon l'ajoute
  638.             $user->addProtocole($protocole);
  639.             $entityManager->flush();
  640.         }
  642.         return $this->redirectToRoute('protocole_page', ['id' => $protocole->getId(), 'nom' => $protocole->getTitre()]);
  643.     }
  645.     #[Route("/addusermateriel/{id}", name:"addusermateriel")]
  646.     public function addusermateriel(Materiel $materiel, EntityManagerInterface $entityManager): Response
  647.     {
  648.         //force le user courant par sécurité ;-)
  649.         $user = $this->getUserEntity();        
  650.         if ($user != null) {
  651.             //test si existe déjà
  652.             foreach($user->getMateriels() as $usermat){
  653.                 if($usermat->getId() == $materiel->getId()) {
  654.                     return new Response(true); //existe déjà
  655.                 }
  656.             }
  657.             //sinon l'ajoute
  658.             $user->addMateriel($materiel);
  659.             $entityManager->flush();
  660.         }
  661.         return $this->redirectToRoute('materiel_page', ['id' => $materiel->getId()]);
  662.     }
  664.     #[Route("/removeuserprotocole/{id}", name:"removeuserprotocole_ajax")]
  665.     public function removeuserprotocole(Protocole $protocole, EntityManagerInterface $entityManager): Response
  666.     {
  667.         //force le user courant par sécurité ;-)
  668.         $user = $this->getUserEntity(); 
  669.         if ($user != null) { 
  670.             $user->removeProtocole($protocole);
  671.             $entityManager->flush();
  672.         }
  673.         return $this->redirectToRoute('protocole_page', ['id' => $protocole->getId(), 'nom' => $protocole->getTitre()]);
  674.     }
  676.     #[Route("/removeusermateriel/{id}", name:"removeusermateriel_ajax")]
  677.     public function removeusermateriel(Materiel $materiel, EntityManagerInterface $entityManager): Response
  678.     {
  679.         //force le user courant par sécurité ;-)
  680.         $user = $this->getUserEntity(); 
  681.         if ($user != null) { 
  682.             $user->removeMateriel($materiel);
  683.             $entityManager->flush();
  684.         }
  685.         return $this->redirectToRoute('materiel_page', ['id' => $materiel->getId()]);
  686.     }
  689.     #[Route("/removecompteprotocole/{id}", name:"removecompteprotocole_page")]
  690.     public function removecompteprotocole(Protocole $protocole, EntityManagerInterface $entityManager): Response
  691.     {
  692.         //force le user courant par sécurité ;-)
  693.         $user = $this->getUserEntity();    
  694.         if ($user != null) { 
  695.             $user->removeProtocole($protocole);
  696.             $entityManager->flush();
  697.         }
  698.         return $this->redirectToRoute('infoscompte_page');
  699.     }
  702.     #[Route("/removecomptemateriel/{id}", name:"removecomptemateriel_page")]
  703.     public function removecomptemateriel(Materiel $materiel, EntityManagerInterface $entityManager): Response
  704.     {
  705.         //force le user courant par sécurité ;-)
  706.         $user = $this->getUserEntity(); 
  707.         if ($user != null) { 
  708.             $user->removeMateriel($materiel);
  709.             $entityManager->flush();
  710.         }
  711.         return $this->redirectToRoute('infoscompte_page');
  712.     }
  715.     /***********************************************************************************************
  716.      * RECHERCHER
  717.      */
  719.     #[Route("/recherche", name:"recherche_page")]
  720.     public function recherchepage(Request $request, 
  721.                                   ProtocoleRepository $protocoleRepository, 
  722.                                   MaterielRepository $materielRepository,
  723.                                   ArticleRepository $articleRepository,
  724.                                   CategorieRepository $categorieRepository): Response
  725.     {
  726.         $texte = $request->query->get('txtrecherche', ''); 
  727.         $texte = trim($texte);
  728.         if(strlen($texte)>2  && $texte[strlen($texte)-1] == "s") $texte = substr($texte, 0, strlen($texte)-1);
  729.         $enctexte = htmlentities($texte);  //dd( $texte);
  731.         $categories = $categorieRepository->recherche($texte); //dd( $categories);
  732.         $protocoles1 = $protocoleRepository->rechercheTitre($texte, $enctexte); //dd( $protocoles);
  733.         $protocoles2 = $protocoleRepository->rechercheAutres($texte, $enctexte); //dd( $protocoles);
  734.         $materiels1 = $materielRepository->rechercheTitre($texte, $enctexte); //dd( $materiels);
  735.         $materiels2 = $materielRepository->rechercheAutres($texte, $enctexte); //dd( $materiels);
  736.         $articles = $articleRepository->recherche($texte, $enctexte); //dd( $articles);
  737.         
  739.         return $this->render('home/recherches.html.twig', [ 
  740.             'texte'=> $texte,
  741.             'protocoles1'=> $protocoles1,
  742.             'protocoles2'=> $protocoles2,
  743.             'materiels1'=> $materiels1,
  744.             'materiels2'=> $materiels2,
  745.             'articles'=> $articles,
  746.             'categories'=> $categories,
  747.         ]);
  748.     }
  751.      /***********************************************************************************************
  752.      * MENU PAGE
  753.      */
  754.     #[Route("/menu", name:"menu_page")]
  755.     public function menuPage(CategorieRepository $categorieRepository) {
  756.        
  757.         return $this->render('menu/menuPage.html.twig', 
  758.         [
  759.             'protocoles' => $categorieRepository->findOneBy(['titre' => 'Protocoles']),
  760.             'materiels' => $categorieRepository->findOneBy(['titre' => 'Matériels']),
  761.         ]);
  762.     }
  764. }