src/Controller/DemandeServiceController.php line 505

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Controller\Admin\DemandeAffectationCrudController;
  6. use App\Controller\Admin\DemandeNoteCrudController;
  7. use App\Controller\Admin\DemandeServiceCrudController;
  8. use App\Entity\DemandeAffectation;
  9. use App\Entity\DemandeNote;
  10. use App\Entity\DemandeService;
  11. use App\Entity\DemandeServiceCandidat;
  12. use App\Entity\DocDemandeClient;
  13. use App\Entity\FormationsService;
  14. use App\Entity\InterventionEntrepriseService;
  15. use App\Entity\ProgrammeFormationService;
  16. use App\Entity\Service;
  17. use App\Entity\User;
  18. use App\Form\DemandeServiceType;
  19. use App\Form\DocDemandeClientType;
  20. use App\Model\Globals;
  21. use App\Service\FileUploader;
  22. use App\Service\NotificationManager;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  25. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  26. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  27. use Symfony\Component\HttpFoundation\RequestStack;
  28. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  29. use ZipArchive;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\Routing\Annotation\Route;
  36. class DemandeServiceController extends AbstractController
  37. {
  38.     /**
  39.      * @var EntityManagerInterface
  40.      */
  41.     protected $em;
  44.     /**
  45.      * @var RequestStack
  46.      */
  47.     private $request;
  49.     /**
  50.      * @var FileUploader
  51.      */
  52.     protected $fileUploader;
  54.     /**
  55.      * @var AdminUrlGenerator
  56.      */
  57.     private $adminUrlGenerator;
  59.     private $notificationManager;
  62.     /**
  63.      * @param EntityManagerInterface $em
  64.      */
  65.     public function __construct(EntityManagerInterface $em, FileUploader $fileUploader, 
  66.     RequestStack $request, AdminUrlGenerator $adminUrlGenerator, NotificationManager $notificationManager)
  67.     {
  68.         $this->em = $em;
  69.         $this->request = $request;
  70.         $this->fileUploader = $fileUploader;
  71.         $this->adminUrlGenerator = $adminUrlGenerator;
  72.         $this->notificationManager = $notificationManager;
  73.     }
  75.     /**
  76.      * @param int $serviceId
  77.      * @return \Symfony\Component\HttpFoundation\RedirectResponse|\Symfony\Component\HttpFoundation\Response
  78.      */
  79.     #[Route('/new/demande/{serviceId}/{demandeId}', name: 'new_demande')]
  80.     public function newDemande(int $serviceId,EntityManagerInterface $entityManager,
  81.      int $demandeId, Request $request, NotificationManager $notificationManager , UrlGeneratorInterface $urlGenerator)
  82.     {
  83.         if (null === $this->getUser()) {
  84.             return $this->redirectToRoute('login');
  85.         }
  86.         $service = $this->em->getRepository(Service::class)->find($serviceId);
  87.         $dataOptions['attr_translation_parameters']['service'] = $service;
  88.         $dataOptions['attr_translation_parameters']['user'] = $this->getUser();
  89.         $demandeServiceData = ($demandeId === 0) ? new DemandeService() : $this->em->getRepository(DemandeService::class)->find($demandeId) ;
  91.         if ( ( true === $demandeServiceData->isIsVerified() ) && 0 !== $demandeId ) {
  92.             $this->addFlash('error', 'Votre demande a été bien reçue');
  93.             return $this->redirectToRoute('app_list_demande');
  94.         }
  95.         foreach ($this->getUser()->getAdresses() as $value) {
  96.             $address = $value;
  97.         }
  98.         $form = $this->createForm(DemandeServiceType::class, $demandeServiceData, $dataOptions);
  99.         $form->handleRequest($request);
  100.         if ($form->isSubmitted() && $form->isValid()) {
  101.             $demandeService = $form->getData();
  102.             $demandeService->setIsDeleted(false);
  103.             $demandeService->setIsVerified(false);
  104.             $demandeService->setIsValid(false);
  105.             $demandeService->setEnabled(true);
  106.             $demandeService->setAcceptDocuments(false);
  107.             if ($demandeId === 0) {
  108. //                if ($service instanceof InterventionEntrepriseService) {
  109.                 $demandeService->setEtat(Globals::DEMANDE_ETAT_EN_COURS);
  110. //                } else {
  111. //                    $demandeService->setEtat(Globals::DEMANDE_ETAT_ATTENTE_VALIDATION);
  112. //                }
  113.                 $demandeService->setCreatedBy($this->getUser()->getId());
  114.                 $demandeService->setService($service);
  115.                 if( $demandeService->getPrestation() ){
  116.                     $demandeService->setRubrique($demandeService->getPrestation()->getRubrique());
  117.                 }elseif( $service->getRubriques() ){
  118.                     $demandeService->setRubrique( $service->getRubriques()[0] );
  119.                     $demandeService->setPrestation( $service->getRubriques()[0]->getPrestations()[0] );
  120.                 }
  121.                 $demandeService->setUser($this->getUser());
  122.             } else {
  123.                 $demandeService->setUpdatedBy($this->getUser()->getId());
  124.                 $demandeService->setUpdatedAt(new \DateTime());
  125.             }
  126.             if ($service instanceof FormationsService) {
  127.                 $demandeService->setProcessType(Globals::FORMATION_PROCESS_TYPE);
  128.             }
  129.             $this->em->persist($demandeService);
  130.             $this->em->flush();
  131.             if ($service instanceof FormationsService) {
  132.                 $demandeServiceCandidatData = $this->em->getRepository(DemandeServiceCandidat::class)->findBy(['demandeService' => $demandeService]);
  133.                 if (0 < count($demandeServiceCandidatData)) {
  134.                     foreach ($demandeServiceCandidatData as $candidat) {
  135.                         $this->em->getRepository(DemandeServiceCandidat::class)->remove($candidat, true);
  136.                     }
  137.                 }
  138.                 if (true === array_key_exists('candidats', $this->request->getCurrentRequest()->request->all())) {
  139.                
  140.                     $candidats = $this->request->getCurrentRequest()->request->all()['candidats'];
  141.                     $demandeServiceCandidat = [];
  142.                     foreach ($candidats['name'] as $i => $name) {
  143.                         $demandeServiceCandidat[$i] = new DemandeServiceCandidat();
  144.                         $demandeServiceCandidat[$i]->setNomPrenom($name);
  145.                         $demandeServiceCandidat[$i]->setDemandeService($demandeService);
  146.                         $demandeServiceCandidat[$i]->setDeleted(false);
  147.                         $demandeServiceCandidat[$i]->setCreatedBy($this->getUser()->getId());
  148.                         $demandeServiceCandidat[$i]->setCreatedAt(new \DateTime());
  149.                     }
  150.                     foreach ($candidats['email'] as $i => $email) {
  151.                         $demandeServiceCandidat[$i]->setEmail($email);
  152.                     }
  153.                     foreach ($candidats['niveauInstruction'] as $i => $niveauInstruction) {
  154.                         $demandeServiceCandidat[$i]->setNiveauInstruction($niveauInstruction);
  155.                     }
  156.                     foreach ($candidats['affectation'] as $i => $aff) {
  157.                         $demandeServiceCandidat[$i]->setAffectation($aff);
  158.                     }
  159.                     foreach ($candidats['anciennete'] as $i => $anciennete) {
  160.                         $demandeServiceCandidat[$i]->setAnciennete($anciennete);
  161.                         $this->em->persist($demandeServiceCandidat[$i]);
  162.                         $this->em->flush();
  163.                     }
  164.                 }
  165.             }
  166.             $this->addFlash('success', 'Demande enregistrée avec succès');
  168.             // Send Comment
  169.             $url = $this->adminUrlGenerator
  170.             ->setController(DemandeServiceCrudController::class)
  171.             ->setAction(Action::INDEX)
  172.             ->generateUrl();
  173.        
  174.             // Variables définies pour l'URL
  175.             $encodedReferrerUrl = urlencode($url);
  176.             $crudControllerFqcn = 'App\Controller\Admin\DemandeServiceCrudController';
  177.             $entityFqcn = 'App\Entity\DemandeService';
  178.             $filterComparison = '=';
  179.             $filterValue = $demandeService->getId();
  180.             $filterValue2 = ''; // Assuming this is an empty value
  182.             // Génération de l'URL avec les paramètres supplémentaires
  183.             $edit_demande_url = $this->adminUrlGenerator
  184.                 ->setController($crudControllerFqcn)
  185.                 ->setAction(Action::INDEX)
  186.                 ->set('referrer', $encodedReferrerUrl)
  187.                 ->set('crudAction', 'index')
  188.                 ->set('crudControllerFqcn', $crudControllerFqcn)
  189.                 ->set('entityFqcn', $entityFqcn)
  190.                 ->set('filters[id][comparison]', $filterComparison)
  191.                 ->set('filters[id][value]', $filterValue)
  192.                 ->set('filters[id][value2]', $filterValue2)
  193.                 ->generateUrl();
  194.             $notification_message = 'Mise à jour de demande  ';
  195.             $repository = $entityManager->getRepository(User::class);
  197.             $queryBuilder = $repository->createQueryBuilder('u');
  198.             $daes = $entityManager->getRepository(User::class)->findByRole('ROLE_DAE');
  199.             $CAs = $entityManager->getRepository(User::class)->findByRole('ROLE_CHARGE_ASSISTANCE');
  200.              foreach($daes as $dae) {
  201.                 $notificationManager->pushMessage($notification_message, $notification_message, $dae, $edit_demande_url);
  203.             }
  204.             foreach($CAs as $ca) {
  205.                  if($ca->getUniteRegional()->getAdresse()->getGouvernorat() == $demandeService->getGouvernorat() ){
  206.                     $notificationManager->pushMessage($notification_message, $notification_message, $ca, $edit_demande_url);
  208.                  }
  210.             }
  212.             
  213.             // End send comment
  215.             return $this->redirectToRoute('app_list_demande');
  216.         }
  217.         return $this->render('service/demande/new.html.twig', [
  218.             'user' => $this->getUser(),
  219.             'userRole' => $this->getUser()->getRoles(),
  220.             'service' => $service,
  221.             'isInstanceofFormation' => ($service instanceof FormationsService),
  222.             'isInstanceOfInterventionEntreprise' => ($service instanceof InterventionEntrepriseService),
  223.             'isInstanceOfProgrammeFormation' => ($service instanceof ProgrammeFormationService),
  224.             'form' => $form->createView(),
  225.             'demandeId' => $demandeId,
  226.             'address' => $address,
  227.             'etatRefus' => Globals::DEMANDE_ETAT_REFUSER,
  228.             'demande' => $demandeServiceData,
  229.             'show' => false
  231.         ]);
  232.     }
  234.    /**
  235.      * @return \Symfony\Component\HttpFoundation\RedirectResponse|\Symfony\Component\HttpFoundation\Response
  236.      */
  237.     #[Route('/comment/demande/{demandeId}', name: 'comment_demande')]
  238.     public function listCommentDemande( int $demandeId, Request $request , EntityManagerInterface $entityManager)
  239.     {
  240.         
  241.         $listCommentDemande = $this->em->getRepository(DemandeNote :: class)->findBy(['demande' => $demandeId]);
  242.         if (null === $this->getUser()) {
  243.             return $this->redirectToRoute('login');
  244.         }
  246.       
  248.         $referrerUrl = $this->adminUrlGenerator
  249.     ->setController(DemandeServiceCrudController::class)
  250.     ->setAction('index')
  251.     ->set('entityFqcn', 'App\\Entity\\DemandeService')
  252.     ->generateUrl();
  254.     $edit_demande_url = $this->adminUrlGenerator
  255.         ->setController(DemandeNoteCrudController::class)
  256.         ->setAction('index')
  257.         ->set('demandeServiceId', $demandeId)
  258.         ->set('referrer', $referrerUrl)
  259.         ->generateUrl();
  260.         $notification_message = 'Nouvelle Note / Note modifiée !   ';
  261.         $currentUser = $this->getUser();
  262.         $admins = $entityManager->getRepository(User::class)
  263.             ->createQueryBuilder('u')
  264.             ->where('u != :currentUser')
  265.             ->setParameter('currentUser', $currentUser)
  266.             ->andWhere('u.roles LIKE :role1 OR u.roles LIKE :role2 ')
  267.             ->setParameter('role1', '%ROLE_CHARGE_ASSISTANCE%')
  268.             ->setParameter('role2', '%ROLE_DAE%')
  269.             ->getQuery()
  270.             ->getResult();
  271.             $listAffectations = $entityManager->getRepository(DemandeAffectation::class)->findBy(['demandeService'=> $demandeId]);
  272.         foreach ($admins as $admin) {
  273.             $this->notificationManager->pushMessage('Nouvelle Note / Note modifiée! ', $notification_message, $admin, $edit_demande_url);
  274.         }
  276.             return $this->render('service/demande/note_list.html.twig', [
  277.                 'listCommentDemandes' => $listCommentDemande,
  278.                 'demandeId' => $demandeId
  279.             ]);
  281.         
  282.     }
  283.   
  284.     
  285.     /**
  286.      * @return \Symfony\Component\HttpFoundation\Response
  287.      */
  288.     #[Route('/demande/list', name: 'app_list_demande')]
  289.     public function listDemande()
  290.     {
  291.         $demandesDates = [];
  292.         $demandes = $this->em->getRepository(DemandeService::class)->findBy(['user' => $this->getUser(), 'isDeleted' => false]);
  294.         foreach( $demandes as $demande ){
  295.             $dateDebut = null;
  296.             $dateFin = null;
  298.             if( $demande->getGroupeDemande() ){
  299.                 $demandesModules = $this->em->getRepository(DemandeService::class)->getDemandesModuleOfGroupe( $demande->getGroupeDemande()->getId() );
  300.                 dump( $demande->getId(), $demandesModules);
  301.                 foreach ( $demandesModules as $demandeModule ){
  302.                     if ( $demandeModule->getTachExecutionDateDebut() and $dateDebut == null){
  303.                         $dateDebut = $demandeModule->getTachExecutionDateDebut();
  304.                     }
  306.                     $dateFin = $demandeModule->getTachExecutionDateFin();
  307.                 }
  308.             }
  310.             $demandesDates[ $demande->getId() ] = [
  311.                 'dateDebut' => $dateDebut,
  312.                 'dateFin' => $dateFin,
  313.             ];
  314.         }
  316.         return $this->render('service/demande/list.html.twig', [
  317.             'demandes' => $demandes,
  318.             'demandesDates' => $demandesDates,
  319.             'etatDocValid' => Globals::DOC_ETAT_VALIDE,
  320.             'etatEncours' => Globals::DEMANDE_ETAT_EN_COURS,
  321.             'etatEnAttente' => Globals::DEMANDE_ETAT_ATTENTE_VALIDATION,
  322.             'etatRefuser' => Globals::DEMANDE_ETAT_REFUSER,
  323.             'etatCloturer' => Globals::DEMANDE_ETAT_CLOTURER,
  325.         ]);
  326.     }
  328.     /**
  329.      * @param int $id
  330.      * @return \Symfony\Component\HttpFoundation\RedirectResponse
  331.      */
  332.     #[Route('/demande/delete/{id}', name: 'app_delete_demande')]
  333.     public function deleteDemande(int $id)
  334.     {
  335.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  336.         if ( true === $demande->isIsVerified() ) {
  337.             $this->addFlash('error', 'Votre demande a été bien reçue');
  338.             return $this->redirectToRoute('app_list_demande');
  339.         }
  340.         $demande->setIsDeleted(true);
  341.         $demande->setDeletedAt(new \DateTime());
  342.         $this->em->persist($demande);
  343.         $this->em->flush();
  344.         $edit_demande_url = $this->adminUrlGenerator
  345.         ->setController(DemandeServiceCrudController::class)
  346.         ->setAction(Action::INDEX)
  347.         ->generateUrl();
  348.         $notification_message = 'Demande supprimée!   ';
  349.         $currentUser = $this->getUser();
  350.         $admins = $this->em->getRepository(User::class)
  351.             ->createQueryBuilder('u')
  352.             ->where('u != :currentUser')
  353.             ->setParameter('currentUser', $currentUser)
  354.             ->andWhere('u.roles LIKE :role1 OR u.roles LIKE :role2 ')
  355.             ->setParameter('role1', '%ROLE_CHARGE_ASSISTANCE%')
  356.             ->setParameter('role2', '%ROLE_DAE%')
  357.             ->getQuery()
  358.             ->getResult();
  359.         foreach ($admins as $admin) {
  360.             $this->notificationManager->pushMessage('Demande supprimée ! ', $notification_message, $admin, $edit_demande_url);
  361.         }
  362.         $this->addFlash('success', 'Demande supprimé avec succès');
  363.         return $this->redirectToRoute('app_list_demande');
  364.     }
  366.     /**
  367.      * @param int $id
  368.      * @return \Symfony\Component\HttpFoundation\Response
  369.      */
  370.     #[Route('/demande/show/{id}', name: 'app_show_demande')]
  371.     public function showDemande(int $id)
  372.     {
  373.         $demandeServiceData = $this->em->getRepository(DemandeService::class)->find($id);
  374.         $dataOptions['attr_translation_parameters']['service'] = $demandeServiceData->getService();
  375.         $dataOptions['attr_translation_parameters']['user'] = $demandeServiceData->getUser();
  376.         $dataOptions['row_attr']['show'] = true;
  377.         $form = $this->createForm(DemandeServiceType::class, $demandeServiceData, $dataOptions);
  378.         return $this->render('service/demande/new.html.twig', [
  379.             'user' => $demandeServiceData->getUser(),
  380.             'service' => $demandeServiceData->getService(),
  381.             'isInstanceofFormation' => ($demandeServiceData->getService() instanceof FormationsService),
  382.             'isInstanceOfInterventionEntreprise' => ($demandeServiceData->getService() instanceof InterventionEntrepriseService),
  383.             'isInstanceOfProgrammeFormation' => ($demandeServiceData->getService() instanceof ProgrammeFormationService),
  384.             'form' => $form->createView(),
  385.             'demandeId' => $demandeServiceData->getId(),
  386.             'demande' => $demandeServiceData,
  387.             'show' => true
  389.         ]);
  390.     }
  393.     #[Route('/demande/verif/{id}', name: 'app_verif_demande')]
  394.     public function verifDemande(int $id)
  395.     {
  396.         $url = $this->adminUrlGenerator
  397.             ->setController(DemandeServiceCrudController::class)
  398.             ->setAction(Action::INDEX)
  399.             ->generateUrl();
  400.         $demandeService = $this->em->getRepository(DemandeService::class)->find($id);
  401.         if (true === $this->isGranted('ROLE_CHARGE_ASSISTANCE') || true === $this->isGranted('ROLE_DAE')) {
  402.             $demandeService->setIsverified(true);
  403.             $demandeService->setVerifiedBy($this->getUser()->getId());
  404.             $demandeService->setVerifiedAt(new \DateTime());
  405.             $demandeService->setEtat(Globals::DEMANDE_ETAT_ATTENTE_VALIDATION);
  406.             $this->em->persist($demandeService);
  407.             $this->em->flush($demandeService);
  408.             $this->addFlash('success', "Demande vérifié avec succès");
  409.             return $this->redirect($url);
  410.         } else {
  411.             $this->addFlash('error', 'Accès interdit');
  412.             return $this->redirect($url);
  413.         }
  414.     }
  417.     #[Route('/demande/print/{id}', name: 'app_print_demande')]
  418.     public function printDemande(int $id)
  419.     {
  420.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  421.         return $this->render('service/demande/print_demande.html.twig', [
  422.             'demande' => $demande
  423.         ]);
  424.     }
  426.     /**
  427.      * @param int $id
  428.      * @return \Symfony\Component\HttpFoundation\RedirectResponse
  429.      */
  430.     #[Route('/demande/valider/{id}', name: 'valid_demande')]
  431.     public function validerDemande(int $id)
  432.     {
  433.         $url = $this->adminUrlGenerator
  434.             ->setController(DemandeServiceCrudController::class)
  435.             ->setAction(Action::INDEX)
  436.             ->generateUrl();
  437.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  438.         if (true === $this->isGranted('ROLE_DAE')) {
  439.             $demande->setIsValid(true);
  440.             $demande->setValidBy($this->getUser()->getId());
  441.             $demande->setValidAt(new \DateTime());
  442.             $demande->setEtat(Globals::DEMANDE_ETAT_VALIDE);
  443.             $this->em->persist($demande);
  444.             $this->em->flush($demande);
  445.             $this->addFlash('success', "Demande Validée avec succès");
  446.             return $this->redirect($url);
  447.         } else {
  448.             $this->addFlash('error', 'Accès interdit');
  449.             return $this->redirect($url);
  450.         }
  451.     }
  454.     /**
  455.      * @param int $id
  456.      * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
  457.      */
  458.     #[Route('/demande/download/{id}', name: 'download_doc_demande')]
  459.     public function downloadDocDemande(int  $id)
  460.     {
  461.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  462.         $zipArchive = new ZipArchive();
  463.         $zipArchive->open($this->getParameter('uploads_directory').'/affectations/doc_demande_zip_'.$demande->getId().'.zip', ZipArchive::CREATE);
  464.         if (0 < count($demande->getDemandeAffectation())) {
  465.             foreach ($demande->getDemandeAffectation() as $affectation) {
  466.                 if (0 < count($affectation->getDocDemandeService())) {
  467.                     foreach ($affectation->getDocDemandeService() as $file) {
  468.                         if (true === in_array('ROLE_AGENT_INTERNE', $file->getUser()->getRoles()) && true === $file->isExterne() && 'import_conseiller' === $file->getType() && Globals::DOC_ETAT_VALIDE === $file->getEtat()) {
  469.                             $zipArchive->addFile($this->getParameter('uploads_directory') . '/affectations/' . $affectation->getId() . '/' . $file->getFileName(), $file->getOriginalFileName());
  470.                         }
  471.                     }
  472.                 }
  473.             }
  474.         }
  475.         $zipArchive->close();
  476.         if (true === file_exists($this->getParameter('uploads_directory').'/affectations/doc_demande_zip_'.$demande->getId().'.zip')) {
  477.             return $this->file($this->getParameter('uploads_directory').'/affectations/doc_demande_zip_'.$demande->getId().'.zip')->deleteFileAfterSend();
  478.         }
  479.         $this->addFlash('error', 'Documents : accès interdit ! ');
  480.         return $this->redirectToRoute('app_list_demande');
  481.     }
  484.     /**
  485.      * @param int $demandeId
  486.      * @return \Symfony\Component\HttpFoundation\Response
  487.      */
  488.     #[Route('/demande/doc/list/{demandeId}', name: 'list_doc_demande')]
  489.     public function docList(int $demandeId)
  490.     {
  491.         $demande = $this->em->getRepository(DemandeService::class)->find($demandeId);
  492.         $docDemandeClient = $this->em->getRepository(DocDemandeClient::class)->findBy(['demandeService' => $demande, 'deleted' => false]);
  493.         return $this->render('service/demande/doc_list.html.twig', [
  494.             'demande' => $demande,
  495.             'docs' => $docDemandeClient
  497.         ]);
  498.     }
  500.     /**
  501.      * @param int $demandeId
  502.      * @return \Symfony\Component\HttpFoundation\Response
  503.      */
  504.     #[Route('/demande/doc/add/{demandeId}/{docId}', name: 'add_doc_demande')]
  505.     public function addDoc(int $demandeId, int $docId = 0, Request $request,NotificationManager $notificationManager,)
  506.     {
  507.         $docDemandeClient = ($docId === 0) ? new DocDemandeClient() : $this->em->getRepository(DocDemandeClient::class)->find($docId);
  508.         $oldFileName = '';
  509.         if ($docId !== 0) {
  510.             $oldFileName = $this->em->getRepository(DocDemandeClient::class)->find($docId)->getFileName();
  511.         }
  512.         $form = $this->createForm(DocDemandeClientType::class, $docDemandeClient);
  513.         $form->handleRequest($request);
  515.         if ($form->isSubmitted() && $form->isValid()) {
  516.             $demande = $this->em->getRepository(DemandeService::class)->find($demandeId);
  517.             $edit_demande_url = "";
  518.             $docDemandeClient = $form->getData();
  519.             $docDemandeClient->setDemandeService($demande);
  520.             $docDemandeClient->setCreatedBy($this->getUser()->getId());
  521.             $docDemandeClient->setCreatedAt(new \DateTime());
  522.             $docDemandeClient->setDeleted(false);
  523.             $file = $this->request->getCurrentRequest()->files->get('doc_demande_client')['fileName'];
  524.             if (null !== $file) {
  525.                 $docDemandeClient->setOriginalFileName($file->getClientOriginalName());
  526.                 $newFileName = $this->fileUploader->upload($file, '/demandes/' . $demande->getId(), 'docaff' );
  527.                 $docDemandeClient->setFileName($newFileName);
  528.                 if ($docId !== 0 && true === file_exists($this->getParameter('uploads_directory').'/demandes/'.$docDemandeClient->getDemandeService()->getId().'/'.$oldFileName)) {
  529.                     unlink($this->getParameter('uploads_directory').'/demandes/'.$docDemandeClient->getDemandeService()->getId().'/'.$oldFileName);
  530.                 }
  531.             }
  532.             $this->em->persist($docDemandeClient);
  533.             $this->em->flush();
  534.             $edit_demande_url =  $this->adminUrlGenerator
  535.             ->setController(DemandeServiceCrudController::class)
  536.             ->setAction(Action::INDEX)
  537.             ->set('filters[id][comparison]', '=')
  538.             ->set('filters[id][value]',  $demande->getId())
  539.             ->generateUrl();         
  540.     
  542.             $notification_message ="Mise à jour de document d'une demande !";
  543.  
  546.             $daes = $this->em->getRepository(User::class)->findByRole('ROLE_DAE');
  547.             $CAs = $this->em->getRepository(User::class)->findByRole('ROLE_CHARGE_ASSISTANCE');
  548.              foreach($daes as $dae) {
  549.                 $notificationManager->pushMessage($notification_message, $notification_message, $dae, $edit_demande_url);
  551.             }
  552.             foreach($CAs as $ca) {
  553.                  if($ca->getUniteRegional()->getAdresse()->getGouvernorat() == $demande->getGouvernorat() ){
  554.                     $notificationManager->pushMessage($notification_message, $notification_message, $ca, $edit_demande_url);
  556.                  }
  558.             }
  559.             $this->addFlash('success', 'Documents ajouté avec succès');
  560.             return $this->redirectToRoute('list_doc_demande', ['demandeId' => $demande->getId()]);
  561.         }
  562.         return $this->render('service/demande/add_doc.html.twig', [
  563.             'form' => $form->createView()
  564.         ]);
  565.     }
  567.     /**
  568.      * @param int $id
  569.      * @return \Symfony\Component\HttpFoundation\BinaryFileResponse|\Symfony\Component\HttpFoundation\RedirectResponse
  570.      */
  571.     #[Route('/demande/doc/download/{id}', name: 'download_doc_client')]
  572.     public function downloadDocClient(int $id)
  573.     {
  574.         $docDemande = $this->em->getRepository(DocDemandeClient::class)->find($id);
  575.         if (true === file_exists($this->getParameter('uploads_directory').'/demandes/'.$docDemande->getDemandeService()->getId().'/'.$docDemande->getFileName())) {
  576.             return $this->file($this->getParameter('uploads_directory').'/demandes/'.$docDemande->getDemandeService()->getId().'/'.$docDemande->getFileName());
  577.         }
  578.         $this->addFlash('error', 'Document introuvable ! ');
  579.         return $this->redirectToRoute('list_doc_demande', [ 'demandeId' =>  $docDemande->getDemandeService()->getId() ]);
  580.     }
  582.     /**
  583.      * @param int $id
  584.      * @return \Symfony\Component\HttpFoundation\BinaryFileResponse|\Symfony\Component\HttpFoundation\RedirectResponse
  585.      */
  586.     #[Route('/demande/doc/delete/{id}', name: 'app_delete_doc')]
  587.     public function deleteDocClient(int $id)
  588.     {
  589.         $docDemande = $this->em->getRepository(DocDemandeClient::class)->find($id);
  590.         $docDemande->setDeleted(true);
  591.         $this->em->persist($docDemande);
  592.         $this->em->flush();
  593.         $this->addFlash('error', 'Documents : supprimé avec succès ! ');
  594.         return $this->redirectToRoute('list_doc_demande', ['demandeId' => $docDemande->getDemandeService()->getId()]);
  595.     }
  597.     /**
  598.      * @param int $id
  599.      * @return \Symfony\Component\HttpFoundation\RedirectResponse
  600.      */
  601.     #[Route('/demande/doc/accept/{id}', name: 'accept_document')]
  602.     public function acceptDocDeamnde(int $id)
  603.     {
  604.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  605.         $demande->setAcceptDocuments(true);
  606.         $this->em->persist($demande);
  607.         $this->em->flush();
  608.         $this->addFlash('error', 'Documents : accepté avec succès ! ');
  609.         return $this->redirectToRoute('app_list_demande');
  610.     }
  612.     /**
  613.      * @return \Symfony\Component\HttpFoundation\RedirectResponse
  614.      */
  615.     #[Route('/demande/back', name: 'admin_list')]
  616.     public function backToAdminList()
  617.     {
  618.         $url = $this->adminUrlGenerator
  619.             ->setController(DemandeServiceCrudController::class)
  620.             ->setAction(Action::INDEX)
  621.             ->generateUrl();
  622.         if (true === $this->isGranted('ROLE_AGENT_INTERNE')) {
  623.             $url = $this->adminUrlGenerator
  624.                 ->setController(DemandeAffectationCrudController::class)
  625.                 ->setAction(Action::INDEX)
  626.                 ->generateUrl();
  627.         }
  628.         return $this->redirect($url);
  629.     }
  631.     /**
  632.      * @param int $id
  633.      * @return \Symfony\Component\HttpFoundation\RedirectResponse
  634.      */
  635.     #[Route('/demande/refuser/{id}', name: 'refuser_demande')]
  636.     public function refuserDemande(int $id)
  637.     {
  638.         $motifRefus = $this->request->getCurrentRequest()->request->all()['motifRefus'];
  639.         $demande = $this->em->getRepository(DemandeService::class)->find($id);
  640.         $url = $this->adminUrlGenerator
  641.             ->setController(DemandeServiceCrudController::class)
  642.             ->setAction(Action::INDEX)
  643.             ->generateUrl();
  644.         if (true === $this->isGranted('ROLE_DAE')) {
  645.             $demande->setRefusedBy($this->getUser()->getId());
  646.             $demande->setRefusedAt(new \DateTime());
  647.             $demande->setMotifRefus($motifRefus);
  648.             $demande->setEtat(Globals::DEMANDE_ETAT_REFUSER);
  649.             $this->em->persist($demande);
  650.             $this->em->flush($demande);
  651.             $this->addFlash('success', "Demande refusée avec succès");
  653.             $edit_demande_url = $this->adminUrlGenerator
  654.             ->setController(DemandeServiceCrudController::class)
  655.             ->set('demandeServiceId', $demande)
  656.             ->setAction(Action::INDEX)
  657.             ->generateUrl();
  658.             $notification_message = 'Nouvelle Demande a été acceptée !   ';
  659.             $currentUser = $this->getUser();
  660.             $admins = $this->em->getRepository(User::class)
  661.                 ->createQueryBuilder('u')
  662.                 ->where('u != :currentUser')
  663.                 ->setParameter('currentUser', $currentUser)
  664.                 ->andWhere('u.roles LIKE :role1 OR u.roles LIKE :role2 ')
  665.                 ->setParameter('role1', '%ROLE_CHARGE_ASSISTANCE%')
  666.                 ->setParameter('role2', '%ROLE_DAE%')
  667.                 ->getQuery()
  668.                 ->getResult();
  669.     
  670.             foreach ($admins as $admin) {
  671.                 $this->notificationManager->pushMessage(' Demande a été refusée! ', $notification_message, $admin, $edit_demande_url);
  672.             }
  673.             $userExp = $this->em->getRepository(User::class)->findOneBy(['id'=> $demande->getUser()->getId()]);
  674.            
  675.             $url_user_front = '/demande/list';
  676.             $this->notificationManager->pushMessage('Demande a été refusée! ', $notification_message, $userExp, $url_user_front);
  678.             return $this->redirect($url);
  679.         } else {
  680.             $this->addFlash('error', 'Accès interdit');
  681.             return $this->redirect($url);
  682.         }
  683.     }
  687. /**
  688.  * @Route("/note/add", name="add_note", methods={"POST"})
  689.  */
  690. public function addComment(Request $request, EntityManagerInterface $entityManager): Response
  691. {
  692.     $id = (int)$request->request->get('demandeIdName');
  694.     $demande = $entityManager->getRepository(DemandeService::class)->find($id);
  696.     if (!$demande) {
  697.         return $this->json(['error' => 'Commentaire not found.'], Response::HTTP_NOT_FOUND);
  698.     }
  700.     $noteDemande = new DemandeNote;
  702.     // Update the properties of the DemandeNote entity based on the form data
  703.     $noteDemande->setDescription($request->request->get('commentName'));
  704.     $noteDemande->setDemande($demande);
  705.     $noteDemande->setIsPublic(true);
  707.     // Persist and flush the changes to the database
  708.     $entityManager->persist($noteDemande);
  709.     $entityManager->flush();
  710.     $this->addFlash('success', 'Commentaire a été ajoutée  avec succès');
  712.     return $this->redirectToRoute('comment_demande', ['demandeId' => $id ]);
  714. }
  715.         /**
  716.      * @Route("/note/update/{id}", name="update_note", methods={"POST"})
  717.      */
  718.     public function updateNote(Request $request, int $id, EntityManagerInterface $entityManager): Response
  719.     {
  720.         $demandeNote = $entityManager->getRepository(DemandeNote::class)->find($id);
  722.         if (!$demandeNote) {
  723.             return $this->json(['error' => 'Commentaire not found.'], Response::HTTP_NOT_FOUND);
  724.         }
  726.         $formData = json_decode($request->getContent(), true);
  728.         // Check if 'editComment' key exists in formData
  729.         if (isset($formData['editComment'])) {
  730.             $editComment = $formData['editComment'];
  731.             $demandeNote->setDescription($editComment);
  732.         } else {
  733.         
  734.             return $this->json(['error' => 'editComment key is missing in formData.'], Response::HTTP_BAD_REQUEST);
  735.         }
  737.         // Persist and flush the changes to the database
  738.         $entityManager->persist($demandeNote);
  739.         $entityManager->flush();
  741.         $response = [
  742.             'success' => true,
  743.             'messages' => 'Commentaire a été mis à jour avec succès.',
  744.         ];
  746.         return $this->json($response);
  747.     }
  749.     #[Route('/note/delete/{id}/{demandeId}', name: 'delete_note')]
  750.     public function deleteAction($id,$demandeId, EntityManagerInterface $entityManager)
  751.     {
  752.         $note = $entityManager->getRepository(DemandeNote::class);
  754.         $note = $note->find($id);
  756.         if (!$note) {
  757.             throw $this->createNotFoundException(
  758.                 'Il n\'y a aucun commentaire avec l\'identifiant suivant : ' . $id
  759.             );
  760.         }
  762.         $entityManager->remove($note);
  763.         $entityManager->flush();
  764.    
  765.         $response = [
  766.             'success' => true,
  767.             'messages' => 'suppression effectuée avec succès.',
  768.         ];
  770.         $this->addFlash('success', 'suppression effectuée avec succès');
  773.         return $this->redirectToRoute('comment_demande', ['demandeId' => $demandeId ]);
  774.     
  775.     }
  778.     /**
  779.      * @Route("/note/fetchData/{id}", name="fetch_note_data", methods={"GET"})
  780.      */
  781.     public function fetchData(int $id, EntityManagerInterface $entityManager): Response
  782.     {
  783.         $demandeNote = $entityManager->getRepository(DemandeNote::class)->find($id);
  785.         if (!$demandeNote) {
  786.             return $this->json(['error' => 'Subject not found.'], Response::HTTP_NOT_FOUND);
  787.         }
  788.       
  789.         $response = [
  790.             'id' => $demandeNote->getId(),
  791.             'description' => $demandeNote->getDescription()
  792.         ];
  794.         return $this->json($response);
  795.     }
  796.       /**
  797.      * @Route("/get_candidat_form", name="fcandidat_form", methods={"GET"})
  798.      */
  799.     public function getCandidatForm(Request $request): Response
  800.     {
  801.         $index = $request->query->get('i');
  802.         $content = $this->renderView('include/add_condidat_form.html.twig', ['index' => $index]);
  803.         return new Response($content);
  804.     }
  806. }