src/Controller/CongeController.php line 195

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use JMS\Serializer\SerializationContext;
  6. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  9. use Symfony\Component\HttpFoundation\Response;
  10. use Symfony\Component\Routing\Annotation\Route;
  11. use App\Entity\Conge;
  12. use App\Entity\CongeDroitAnnuel;
  13. use App\Entity\ParametrageTexte;
  14. use App\Entity\RefRole;
  15. use App\Entity\Utilisateur;
  16. use App\Entity\UtilisateurInformation;
  17. use App\Entity\Workflow;
  18. use App\Form\CongeType;
  19. use App\Entity\RefGabarit;
  20. use App\Entity\RefAffectation;
  21. use Doctrine\Persistence\ManagerRegistry;
  22. use Symfony\Component\Mailer\MailerInterface;
  23. use App\Services\GeneratePdf;
  24. use App\Services\AccessRule;
  25. use JMS\Serializer\SerializerInterface;
  26. use Symfony\Component\Mime\Email;
  27. use App\Services\Lib\EmailSHDecision;
  28. use App\Entity\CongeType as CongeTypes;
  29. use App\Entity\DemandeReport;
  30. use Twig\Environment;
  31. use App\Entity\RefAffectationCalendrier;
  32. use Symfony\Component\Mime\Part\DataPart;
  34. /**
  35.  * Class CongeController
  36.  * @package App\Controller
  37.  */
  38. class CongeController extends AbstractController
  39. {
  40.     final public const ERROR_VALIDATION_FORM = 'Erreur lors de la validation du formulaire';
  41.     final public const ERROR_OCCURED = 'Une erreur est survenue';
  42.     final public const ERROR_FILE = 'Fichier introuvable';
  43.     private $doctrine;
  44.     private $mailer;
  45.     private $generatePdf;
  46.     private $accessRule;
  47.     private $serializer;
  48.     private $twig;
  49.     private  $emailSHDecision;
  50.     public function __construct(ManagerRegistry $doctrine, MailerInterface $mailer, GeneratePdf $generatePdf, Environment $twig, AccessRule $accessRule, SerializerInterface $serializer, EmailSHDecision $emailSHDecision)
  51.     {
  52.         $this->doctrine = $doctrine;
  53.         $this->mailer = $mailer;
  54.         $this->generatePdf = $generatePdf;
  55.         $this->accessRule = $accessRule;
  56.         $this->serializer = $serializer;
  57.         $this->emailSHDecision = $emailSHDecision;
  58.         $this->twig = $twig;
  59.     }
  61.     #[Route(path: '/api/conges/{id}', name: 'ctsweb_get_conge', methods: ['GET'], requirements: ['id' => '\d+'])]
  62.     public function detail(Conge $conge): JsonResponse
  63.     {
  64.         $jsonv = [];
  65.         $repositoryUI = $this->doctrine->getManager()->getRepository(UtilisateurInformation::class);
  66.         $uid = $conge->getUtilisateur()->getIdUtilisateur();
  68.         $utilisateurData = $repositoryUI->findDataForPageProfil($uid);
  70.         $accessRuleService = $this->getServiceAccessRule();
  72.         if (!$accessRuleService->hasRightTodetailAccess($conge)) {
  73.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  74.         }
  76.         // Obtenir les données sérialisées de "$conge" et les décoder en tableau associatif
  78.         $congeSerialized = $this->serialize($conge);
  79.         $congeSerializedArray = json_decode($congeSerialized, true);
  80.         // Appeler les méthodes de l'entité "Conge" sur l'objet "$conge"
  81.         $uData = $this->serialize($utilisateurData);
  82.         $jsonv['items']['conge'] = $congeSerializedArray;
  83.         if (isset($jsonv['items']['conge']['items']['pieceMotif'])) {
  84.             $jsonv['items']['conge']['items']['pieceMotif'] = (isset($jsonv['items']['conge']['items']['pieceMotif']) && !empty($jsonv['items']['conge']['items']['pieceMotif'])) ? json_decode((string) $jsonv['items']['conge']['items']['pieceMotif'], true, 512, JSON_THROW_ON_ERROR) : [];
  85.         }
  86.         $jsonv['items']['user'] = json_decode((string) $uData, true, 512, JSON_THROW_ON_ERROR);
  87.         $json_merge = json_encode($jsonv);
  90.         return new JsonResponse($json_merge, JsonResponse::HTTP_OK, [], true);
  91.     }
  93.     #[Route(path: '/api/conges/state/{state}', name: 'ctsweb_list_conge', methods: ['GET'])]
  94.     public function list(string $state): JsonResponse
  95.     {
  96.         $validStates = array_keys(Workflow::STATES);
  98.         if (!in_array($state, $validStates)) {
  99.             return new JsonResponse([], JsonResponse::HTTP_BAD_REQUEST);
  100.         }
  102.         $entityManager = $this->doctrine->getManager();
  103.         $today = new \DateTime();
  105.         if (in_array($state, ['accepted', 'rejected'])) {
  106.             $conges = $entityManager
  107.                 ->getRepository(Conge::class)
  108.                 ->findAllUntillCurrentDate($this->getUser()->getUtilisateur());
  109.             $report = $entityManager
  110.                 ->getRepository(DemandeReport::class)
  111.                 ->findAllUntillCurrentDate($this->getUser()->getUtilisateur());
  112.         } else {
  113.             $conges = $entityManager
  114.                 ->getRepository(Conge::class)
  115.                 ->findAllUntillCurrentWaiting($this->getUser()->getUtilisateur());
  116.             $report = $entityManager
  117.                 ->getRepository(DemandeReport::class)
  118.                 ->findAllUntillCurrentWaiting($this->getUser()->getUtilisateur());
  119.         }
  120.         $dataconges = array_map(function ($conge) use ($today) {
  121.             $congeArray = json_decode((string) $this->serializeto($conge), true, 512, JSON_THROW_ON_ERROR);
  122.             $congeArray[0]['dateDebut'] = date_format(date_create($congeArray[0]['dateDebut']), 'Y-m-d');
  123.             $congeArray[0]['dateFin'] = date_format(date_create($congeArray[0]['dateFin']), 'Y-m-d');
  124.             $congeArray[0]['choixConge'] = 1;
  126.             if ($conge->getDateFin() < $today) {
  127.                 $congeArray[0]['isTooLate'] = true;
  128.             }
  130.             return $congeArray[0];
  131.         }, $conges);
  133.         $newReport = $this->createNewReport();
  135.         $datareport = array_map(function ($report) use ($newReport) {
  136.             $reportArray = json_decode((string) $this->serializeto($report), true, 512, JSON_THROW_ON_ERROR);
  137.             return array_merge($reportArray[0], $newReport);
  138.         }, $report);
  140.         $mergedData = array_merge($dataconges, $datareport);
  142.         return new JsonResponse(
  143.             $this->serialize($mergedData),
  144.             JsonResponse::HTTP_OK,
  145.             [],
  146.             true
  147.         );
  148.     }
  151.     /**
  152.      * @return JsonResponse
  153.      */
  154.     #[Route(path: '/api/conges/archive/{utilisateur}', name: 'ctsweb_conges-archive', methods: ['GET'], requirements: ['utilisateur' => '\d+'])]
  155.     public function findMyArchive(Utilisateur $utilisateur)
  156.     {
  157.         $entityManager = $this->doctrine->getManager();
  159.         $arhives = $entityManager
  160.             ->getRepository(Conge::class)
  161.             ->findBy(
  162.                 [
  163.                     'workflow' => [Workflow::CO_SIGN, Workflow::CO_REJECT, Workflow::CO_ANNULE],
  164.                     'utilisateur' => $utilisateur
  165.                 ],
  166.                 ['dateDebut' => 'DESC']
  167.             );
  169.         $arhivesreport = $entityManager
  170.             ->getRepository(DemandeReport::class)
  171.             ->findBy([
  172.                 'workflow' => [Workflow::RE_SIGN, Workflow::RE_REJECT, Workflow::RE_ANNULE],
  173.                 'utilisateur' => $utilisateur
  174.             ]);
  175.         $newReport = $this->createNewReport();
  177.         $datareport = array_map(function ($arhivesreport) use ($newReport) {
  178.             $reportArray = json_decode((string) $this->serializeto($arhivesreport), true, 512, JSON_THROW_ON_ERROR);
  179.             return array_merge($reportArray[0], $newReport);
  180.         }, $arhivesreport);
  182.         $mergedData = array_merge($arhives,  $datareport);
  183.         return new JsonResponse(
  184.             $this->serialize($mergedData),
  185.             JsonResponse::HTTP_OK,
  186.             [],
  187.             true
  188.         );
  189.     }
  191.     /**
  192.      * @return JsonResponse
  193.      */
  194.     #[Route(path: '/api/conges/management/state/{state}', name: 'ctsweb_list_for_management_conge', methods: ['GET'])]
  195.     public function managementList(string $state)
  196.     {
  198.         $repositoryUI = $this->doctrine->getManager()->getRepository(UtilisateurInformation::class);
  199.         $uid = $this->getUser()->getIdUtilisateur();
  200.         $utilisateurData = $repositoryUI->findDataForPageProfil($uid);
  202.         $role = $this->getUser()->getUtilisateur()->getIdRole();
  204.         if (!in_array($role, Utilisateur::MANAGE)) {
  205.             return new JsonResponse([], JsonResponse::HTTP_FORBIDDEN);
  206.         }
  208.         $states = ['current', 'waiting'];
  210.         if (!in_array($state, $states)) {
  211.             return new JsonResponse([], JsonResponse::HTTP_BAD_REQUEST);
  212.         }
  214.         $entityManager = $this->doctrine->getManager();
  216.         $affectation = $this->getUser()->getIdAffectation();
  217.         $federation = $this->getUser()->getIdFederation();
  219.         if ('waiting' == $state) {
  220.             $workflow = Workflow::CO_WAITING;
  221.             $workflowR = Workflow::RE_WAITING;
  222.             //federation on
  223.             if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role) {
  224.                 $affectation = null;
  225.             } else if (RefRole::ROLE_DR === $role || RefRole::ROLE_DR_SIGNATAIRE === $role || RefRole::ROLE_GCR === $role) {
  226.                 $federation = null;
  227.             } else {
  228.                 $federation = null;
  229.                 $affectation = null;
  230.             }
  231.         } else {
  232.             $workflow = Workflow::CO_ACCEPTED;
  233.             $workflowR = Workflow::RE_SIGN;
  234.             if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role) {
  235.                 $affectation = null;
  236.             } else if (RefRole::ROLE_DR === $role || RefRole::ROLE_DR_SIGNATAIRE === $role || RefRole::ROLE_GCR === $role) {
  237.                 $federation = null;
  238.             } else {
  239.                 $affectation = null;
  240.                 $federation = null;
  241.             }
  242.         }
  244.         if (RefRole::ROLE_DS_ADMIN === $role) {
  245.             $conges = $entityManager
  246.                 ->getRepository(Conge::class)
  247.                 ->findByWorkflowAndUserTypeAdmin($workflow, $federation, $affectation);
  248.             $report = $entityManager
  249.                 ->getRepository(DemandeReport::class)
  250.                 ->findByWorkflowAndUserTypeAdmin($workflowR, $federation, $affectation);
  251.         } else {
  252.             $conges = $entityManager
  253.                 ->getRepository(Conge::class)
  254.                 ->findByWorkflowAndUserType($workflow, $federation, $affectation);
  255.             $report = $entityManager
  256.                 ->getRepository(DemandeReport::class)
  257.                 ->findByWorkflowAndUserType($workflowR, $federation, $affectation);
  258.         }
  260.         if (
  261.             (Workflow::CO_ACCEPTED === $workflow || Workflow::CO_SIGN === $workflow)
  262.             && (in_array($role, Utilisateur::MANAGER))
  263.         ) {
  264.             $today = (new \DateTime())->format("Y-m-d");
  266.             /** @var Conge $conge */
  267.             foreach ($conges as $conge) {
  268.                 $isTooLate = true;
  269.                 $end = clone $conge['dateFin'];
  271.                 if (RefRole::ROLE_DS_ADMIN === $role && $end->modify('+3 month')->format("Y-m-d") > $today) {
  272.                     $isTooLate = false;
  273.                 } elseif ($end->format("Y-m-d") > $today) {
  274.                     $isTooLate = false;
  275.                 }
  277.                 $conge['isTooLate'] = $isTooLate;
  278.             }
  279.         }
  280.         $dataconges = [];
  281.         foreach ($conges as $conge) {
  282.             $cong = array();
  283.             if (isset($conge)) {
  284.                 $cong = json_decode((string) $this->serializeto($conge), true, 512, JSON_THROW_ON_ERROR);
  285.                 if (isset($cong) && (is_countable($cong) ? count($cong) : 0) > 0) {
  286.                     $cong[0]['dateDebut'] = date_format(date_create($cong[0]['dateDebut']), 'Y-m-d');
  287.                     $cong[0]['dateFin'] = date_format(date_create($cong[0]['dateFin']), 'Y-m-d');
  288.                     $dataconges[] = $cong[0];
  289.                 }
  290.             }
  291.         }
  292.         $datareport = [];
  293.         /** @var DemandeReport $report */
  294.         foreach ($report as $reports) {
  295.             if (isset($reports)) {
  296.                 $rep = json_decode((string) $this->serializeto($reports), true, 512, JSON_THROW_ON_ERROR);
  298.                 if (isset($rep) && (is_countable($rep) ? count($rep) : 0) > 0) {
  299.                     // $datareport[] = $rep[0];
  300.                     $newReport = $this->createNewReportDtnSH();
  301.                 }
  302.                 $datareport[] = array_merge($rep[0], $newReport);
  303.             }
  304.         };
  306.         // Fusionner les tableaux $dataconges et $report
  307.         $mergedData = array_merge($dataconges,  $datareport);
  308.         return new JsonResponse(
  309.             $this->serialize($mergedData),
  310.             JsonResponse::HTTP_OK,
  311.             [],
  312.             true
  313.         );
  314.     }
  316.     /**
  317.      * @return JsonResponse
  318.      */
  319.     #[Route(path: '/api/conges', name: 'ctsweb_create_conge', methods: ['POST'])]
  320.     public function create(Request $request)
  321.     {
  323.         $utilisateurInformation = $this->getUser();
  324.         $utilisateur = $utilisateurInformation->getUtilisateur();
  326.         $idRole = $utilisateur->getIdRole();
  327.         $accessRuleService = $this->getServiceAccessRule();
  329.         if (!$accessRuleService->hasRightForTakingDayOff()) {
  330.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  331.         }
  333.         $conge = new Conge();
  335.         $form = $this->handleRequest($request, $conge, 'all', 'post');
  336.         $em = $this->doctrine->getManager();
  337.         $repository = $em->getRepository(Conge::class);
  338.         $reporeport = $em->getRepository(DemandeReport::class);
  339.         try {
  340.             if ($form->isSubmitted() && $form->isValid()) {
  343.                 $entityManager = $this->doctrine->getManager();
  344.                 // $demande_enCours = $reporeport->countCurrentWaiting($year, $this->getUser());
  345.                 // if (!$demande_enCours) {
  346.                 //     // $retour['conge'] = false;
  347.                 //     $retour['demande_report'] = false;
  348.                 //     return $retour;
  349.                 // }
  350.                 // $today = (new \DateTime());
  351.                 // $year = $today->format("Y");
  352.                 // var_dump( $conge->getDateFin());
  353.                 // var_dump(  new \DateTime("$year-09-01"));
  354.                 // die();
  355.                 if ($conge->getCongeType()->getCode() == CongeTypes::CAN || $conge->getCongeType()->getCode() == CongeTypes::RTT) {
  356.                     $id_affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  357.                     $requiredCheval = $this->getChevalConge($conge, $id_affectation);
  358.                     if (!$requiredCheval) {
  359.                         $result = [
  360.                             'success' => false,
  361.                             'error' => sprintf('Votre période de congés est à cheval sur deux années, veuillez déposer une demande par année de gestion')
  362.                         ];
  363.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  364.                     }
  365.                 }
  366.                 if ($conge->getCongeType()->getCode() == CongeTypes::CEX) {
  367.                     $requiredFields = $this->getRequiredMotifOrPieceJointeForCexConge($conge);
  368.                     if (!empty($requiredFields)) {
  369.                         $result = [
  370.                             'success' => false,
  371.                             'error' => sprintf(' %s  pour un congé de type CE', $requiredFields)
  372.                         ];
  373.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  374.                     }
  375.                 }
  376.                 //verifier le soldes des comptes pour le Cet et RAA
  377.                 if ($conge->getCongeType()->getCode() == CongeTypes::CET || $conge->getCongeType()->getCode() == CongeTypes::RAA) {
  378.                     if (!$this->verifier_solde_comptes($conge)) {
  379.                         $result = [
  380.                             'success' => false,
  381.                             'error' => sprintf('Le nombre de jours ouvrés demandé doit être égale ou inférieur au solde de votre %s.', $conge->getCongeType()->getLibelle())
  382.                         ];
  383.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  384.                     }
  385.                 }
  386.                 if ($conge->getCongeType()->getCode() == CongeTypes::RAA) {
  387.                     $id_affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  388.                     if (!$repository->checkDemandeReportAA($conge, $id_affectation)) {
  389.                         $result = [
  390.                             'success' => false,
  391.                             'error' => sprintf('la date de début et la date de fin de congés de  %s doivent être incluses dans la période de débit du report année antérieure fixée par le SH', $conge->getCongeType()->getLibelle())
  392.                         ];
  393.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  394.                     }
  395.                 }
  396.                 if (!$repository->check_chevauchement($conge, $this->getUser()->getIdUtilisateur())) {
  397.                     $result = [
  398.                         'success' => false,
  399.                         'error' => 'Il y a déjà un congé déposé sur cette période'
  400.                     ];
  401.                     return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  402.                 }
  404.                 if (Conge::DTN === $request->request->get('from')) {
  405.                     $conge->setAvisDtn(true);
  406.                 }
  408.                 // $IdUtilisateur = $em->getRepository(Utilisateur::class)->findOneBy(['idUtilisateur' => $this->getUser()->getIdUtilisateur()]);
  409.                 // $conge->setUtilisateur($IdUtilisateur);
  411.                 $entityManager->persist($conge);
  413.                 $entityManager->flush();
  415.                 if ($idRole == RefRole::ROLE_CTS || $idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
  416.                     $this->sendMailNotification();
  417.                 }
  419.                 return new JsonResponse(
  420.                     [
  421.                         'success' => true,
  422.                         'Conge' => $conge->getId()
  423.                     ],
  424.                     JsonResponse::HTTP_CREATED
  425.                 );
  426.             } else {
  427.                 $result = [
  428.                     'success' => false,
  429.                     'data' => self::ERROR_VALIDATION_FORM,
  430.                     'error' => (string) $form->getErrors(true, false)
  431.                 ];
  432.             }
  433.         } catch (\Exception $e) {
  434.             echo $e->getMessage();
  435.             $result = [
  436.                 'success' => false,
  437.                 'data' => self::ERROR_OCCURED
  438.             ];
  439.         }
  441.         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  442.     }
  444.     private function sendMailNotification()
  445.     {
  446.         $em = $this->doctrine->getManager();
  447.         $gabRep = $em->getRepository(RefGabarit::class);
  448.         $ui = $this->getUser();
  449.         $uid = $this->getUser()->getUtilisateur()->getIdUtilisateur();
  450.         $uimail = $em->getRepository(Utilisateur::class)->findBy(['idUtilisateur' => $uid])[0]->getCourriel();
  451.         $role = $this->getUser()->getUtilisateur()->getIdRole();
  453.         $subject = sprintf('CTS-WEB : Congés à valider - %s %s', $ui->getNom(), $ui->getPrenom());
  455.         $emailMailer = $this->getParameter('mailer_user');
  457.         $expediteurMail =  (filter_var($emailMailer, FILTER_VALIDATE_EMAIL)) ? $emailMailer : 'donotreply@sports.gouv.fr';
  459.         //$host = $this->getParameter('host');
  460.         $mail_contact = null;
  461.         $mail_ass_info = $this->doctrine->getManager()->getRepository(ParametrageTexte::class)->getByCode('COURRIEL_ASSISTANCE_INFO');
  462.         if ((is_countable($mail_ass_info) ? count($mail_ass_info) : 0) > 0)
  463.             $mail_contact = $mail_ass_info[0]->getTexte();
  465.         if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role || RefRole::ROLE_CTS === $role) {
  466.             $federation = $ui->getIdFederation()->getIdFederation();
  467.             $affectation = $ui->getIdAffectation()->getIdAffectation();
  468.         } else {
  469.             $federation = null;
  470.             $affectation = $ui->getIdAffectation()->getIdAffectation();
  471.         }
  473.         $recipients = $gabRep->emailNotification($federation, $affectation, 'emailConges');
  476.         // if (!filter_var($recipients, FILTER_VALIDATE_EMAIL)) {
  477.         //     $recipients = [];
  478.         // }
  480.         if (!empty($recipients)) {
  482.             $message = (new Email())
  483.                 ->subject($subject)
  484.                 ->from($expediteurMail)
  485.                 ->to(...$recipients)
  486.                 ->html(
  487.                     $this->twig->render(
  488.                         'Notification/notification_conge_dtn.html.twig',
  489.                         ['host' => $mail_contact, 'civility' => $ui->getCivilite(), 'lastname' => $ui->getNom(), 'firstname' => $ui->getPrenom(), 'mailDemandeur' => $expediteurMail]
  490.                     ),
  491.                     'text/html'
  492.                 );
  493.             $this->mailer->send($message);
  494.         }
  495.     }
  497.     /**
  498.      * @return JsonResponse
  499.      */
  500.     #[Route(path: '/api/update_conges/{id}', name: 'ctsweb_update_conge', methods: ['POST'], requirements: ['id' => '\d+'])]
  501.     public function update(Request $request, Conge $conge)
  502.     {
  503.         $utilisateurInformation = $this->getUser();
  504.         $accessRuleService = $this->getServiceAccessRule();
  505.         $utilisateur = $utilisateurInformation->getUtilisateur();
  506.         $idRole = $utilisateur->getIdRole();
  507.         if (!$accessRuleService->hashRightToModify($conge)) {
  508.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  509.         }
  511.         // $conge = new Conge();
  512.         $form = $this->handleRequest($request, $conge, 'all', 'post');
  514.         $em = $this->doctrine->getManager();
  515.         $repository = $em->getRepository(Conge::class);
  517.         if ($form->isSubmitted() && $form->isValid()) {
  519.             $em = $this->doctrine->getManager();
  520.             $workflow = $em->getRepository(Workflow::class)->find(Workflow::CO_WAITING);
  521.             if (Workflow::CO_SIGN != $conge->getWorkflow()->getIdWorkflow())
  522.                 $conge->setWorkflow($workflow);
  524.             $entityManager = $this->doctrine->getManager();
  525.             // if ($idRole == RefRole::ROLE_CTS || $idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
  526.             if ($idRole == RefRole::ROLE_CTS) {
  527.                 if ($conge->getCongeType()->getCode() == CongeTypes::CAN || $conge->getCongeType()->getCode() == CongeTypes::RTT) {
  528.                     $id_affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  529.                     $requiredCheval = $this->getChevalConge($conge, $id_affectation);
  530.                     if (!$requiredCheval) {
  531.                         $result = [
  532.                             'success' => false,
  533.                             'error' => sprintf('Votre période de congés est à cheval sur deux années, veuillez déposer une demande par année de gestion')
  534.                         ];
  535.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  536.                     }
  537.                 }
  538.                 if ($conge->getCongeType()->getCode() == CongeTypes::CEX) {
  539.                     $requiredFields = $this->getRequiredMotifOrPieceJointeForCexConge($conge);
  540.                     if (!empty($requiredFields)) {
  541.                         $result = [
  542.                             'success' => false,
  543.                             'error' => sprintf(' %s  pour un congé de type CE', $requiredFields)
  544.                         ];
  545.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  546.                     }
  547.                 }
  548.                 //verifier le soldes des comptes pour le Cet et RAA
  549.                 if ($conge->getCongeType()->getCode() == CongeTypes::CET || $conge->getCongeType()->getCode() == CongeTypes::RAA) {
  550.                     if (!$this->verifier_solde_comptes($conge)) {
  551.                         $result = [
  552.                             'success' => false,
  553.                             'error' => sprintf('Le nombre de jours ouvrés demandé doit être égale ou inférieur au solde de votre %s.', $conge->getCongeType()->getLibelle())
  554.                         ];
  555.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  556.                     }
  557.                 }
  558.                 if ($conge->getCongeType()->getCode() == CongeTypes::RAA) {
  559.                     $id_affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  560.                     if (!$repository->checkDemandeReportAA($conge, $id_affectation)) {
  561.                         $result = [
  562.                             'success' => false,
  563.                             'error' => sprintf('la date de début et la date de fin de congés de  %s doivent être incluses dans la période de débit du report année antérieure fixée par le SH', $conge->getCongeType()->getLibelle())
  564.                         ];
  565.                         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  566.                     }
  567.                 }
  568.                 if (!$repository->check_chevauchement($conge, $this->getUser()->getIdUtilisateur())) {
  569.                     $result = [
  570.                         'success' => false,
  571.                         'error' => 'Il y a déjà un congé déposé sur cette période'
  572.                     ];
  573.                     return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  574.                 }
  575.             }
  576.             $entityManager->persist($conge);
  577.             $entityManager->flush();
  580.             $result = ['success' => true];
  581.             $status = JsonResponse::HTTP_OK;
  582.         } else {
  583.             $result = [
  584.                 'success' => false,
  585.                 'data' => self::ERROR_VALIDATION_FORM,
  586.                 'error' => (string) $form->getErrors(true, false)
  587.             ];
  589.             $status = JsonResponse::HTTP_BAD_REQUEST;
  590.         }
  592.         return new JsonResponse($result, $status);
  593.     }
  595.     #[Route(path: '/api/delete_conges/{id}', name: 'ctsweb_delete_conge', requirements: ['id' => '\d+'])]
  596.     public function delete(Conge $conge)
  597.     {
  598.         try {
  599.             $em = $this->doctrine->getManager();
  600.             $repository = $em->getRepository(Conge::class);
  601.             $cg = $repository->findOneBy(['id' => $conge->getId()]);
  603.             if ($cg) {
  604.                 if ($cg->getWorkflow()->getIdWorkflow() == Workflow::CO_SIGN or $cg->getWorkflow()->getIdWorkflow() == Workflow::CO_ACCEPTED) {
  605.                     $workflow = $em->getRepository(Workflow::class)->find(Workflow::CO_ANNULE);
  606.                     $conge->setWorkflow($workflow);
  607.                     $em->persist($conge);
  608.                     $em->flush();
  609.                     $data = ['success' => true, 'data' => 'Le congé a été annulé'];
  610.                     return new JsonResponse($data);
  611.                 } else {
  612.                     $repository->deleteConge($conge->getId());
  613.                     $data = ['success' => true, 'data' => 'Le congé a été supprimé'];
  614.                     return new JsonResponse($data);
  615.                 }
  616.             }
  617.         } catch (\Exception $e) {
  618.             $data = ['success' => false, 'data' => $e->getMessage()];
  619.             return new JsonResponse($data);
  620.         }
  621.     }
  622.     /**
  623.      * @return JsonResponse
  624.      */
  625.     #[Route(path: '/api/conges/{id}/change-status', name: 'ctsweb_change_status_conge', methods: ['POST'], requirements: ['id' => '\d+'])]
  626.     public function changeStatus(Request $request, Conge $conge)
  627.     {
  628.         $accessRuleService = $this->getServiceAccessRule();
  630.         if (!$accessRuleService->isAdmin()) {
  631.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  632.         }
  634.         $form = $this->handleRequest($request, $conge, 'status', 'status');
  636.         if ($form->isSubmitted() && $form->isValid()) {
  638.             $conge->setFrom(Conge::ADMIN);
  640.             $entityManager = $this->doctrine->getManager();
  641.             $entityManager->flush();
  643.             $result = ['success' => true];
  644.             $status = JsonResponse::HTTP_OK;
  645.         } else {
  646.             $result = [
  647.                 'success' => false,
  648.                 'data' => self::ERROR_VALIDATION_FORM,
  649.                 'error' => (string) $form->getErrors(true, false)
  650.             ];
  652.             $status = JsonResponse::HTTP_BAD_REQUEST;
  653.         }
  655.         return new JsonResponse($result, $status);
  656.     }
  658.     /**
  659.      * @return JsonResponse
  660.      */
  661.     #[Route(path: '/api/conges/response/{id}', name: 'ctsweb_response_conge', methods: ['POST'], requirements: ['id' => '\d+'])]
  662.     public function response(Request $request, Conge $conge)
  663.     {
  664.         $form = $this->handleRequest(
  665.             $request,
  666.             $conge,
  667.             'response',
  668.             'response'
  669.         );
  670.         
  671.         $entityManager = $this->doctrine->getManager();
  672.         if ($form->isValid()) {
  673.             
  674.             $accessRuleService = $this->getServiceAccessRule();
  676.             $this->update($request, $conge);
  677.            
  678.             if (Conge::DTN === $conge->getFrom()) {
  679.                 if (!$accessRuleService->hashRightToResponse($conge) && !$accessRuleService->isAdmin()) {
  680.                     return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  681.                 }
  682.                 
  683.                 $congeId = $conge->getId();
  684.                 $avisDtn = ($conge->getResponse()) ? 1 : 0;
  685.                 $update = $entityManager->getRepository(Conge::class)->updateavisDtn($congeId, $avisDtn);
  686.                 // $conge->setAvisDtn($conge->getResponse());
  687.             } elseif (Conge::MANAGER === $conge->getFrom() || Conge::ADMIN === $conge->getFrom()) {
  688.                 $this->setWorkflow($conge);
  689.             }
  690.             $entityManager->flush();
  692.             if ($conge->getResponse() && !is_null($conge->getId())) {
  693.                 $role = $this->getUser()->getUtilisateur()->getIdRole();
  694.                 
  695.                 if (in_array($role, Utilisateur::MANAGER)) {
  696.                     $this->initSignatureConges($conge->getId());
  697.                 }
  698.             }
  700.             $result = ["success" => true];
  701.             $response = JsonResponse::HTTP_OK;
  702.         } else {
  703.             $result = [
  704.                 'success' => false,
  705.                 'data' => self::ERROR_VALIDATION_FORM,
  706.                 'error' => (string) $form->getErrors(true, false)
  707.             ];
  709.             $response = JsonResponse::HTTP_BAD_REQUEST;
  710.         }
  712.         return new JsonResponse($result, $response);
  713.     }
  715.     /**
  716.      * @return JsonResponse
  717.      */
  718.     #[Route(path: '/api/conges/generate-to-print', name: 'ctsweb_print_conge', methods: ['POST'])]
  719.     public function generateToPrint(Request $request)
  720.     {
  722.         $accessRuleService = $this->getServiceAccessRule();
  724.         if (!$accessRuleService->hasRightForTakingDayOff()) {
  725.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  726.         }
  728.         $conge = new Conge();
  730.         $form = $this->handleRequest($request, $conge, 'all', 'post');
  731.         $em = $this->doctrine->getManager();
  732.         $repository = $em->getRepository(Conge::class);
  734.         try {
  735.             if ($form->isSubmitted() && $form->isValid()) {
  736.                 $entityManager = $this->doctrine->getManager();
  737.                 $conge->setUtilisateur($this->getUser()->getUtilisateur());
  738.                 $serviceGeneratePdf = $this->generatePdf;
  739.                 $entityManager->persist($conge);
  740.                 $content = $serviceGeneratePdf->generatePdf($conge, true);
  741.                 $filename = sha1($conge->getId()) . '.pdf';
  742.                 $response = $this->getResponse($content, $filename);
  743.             } else {
  744.                 $response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
  745.             }
  746.         } catch (\Exception) {
  747.             $response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
  748.         }
  750.         return $response;
  751.     }
  753.     /**
  754.      * @return Response
  755.      */
  756.     #[Route(path: '/api/conges/pdf/{id}', name: 'ctsweb_conges_generate-pdf', methods: ['GET'], requirements: ['id' => '\d+'])]
  757.     public function pdf(Conge $conge)
  758.     {
  760.         if (
  761.             Workflow::CO_REJECT === $conge->getWorkflow()->getIdWorkflow()
  762.             || Workflow::CO_SIGN === $conge->getWorkflow()->getIdWorkflow()
  763.         ) {
  764.             $filename = sha1($conge->getId()) . '.pdf';
  765.             $path = $this->getParameter('dir_file_conge') . $filename;
  766.             if (file_exists($path)) {
  767.                 $content = file_get_contents($path, FILE_USE_INCLUDE_PATH);
  769.                 $response = $this->getResponse($content, $filename);
  770.             } else {
  771.                 $response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
  772.             }
  773.         } else {
  774.             $serviceGeneratePdf = $this->generatePdf;
  776.             $content = $serviceGeneratePdf->generatePdf($conge, false);
  777.             $filename = sha1($conge->getId()) . '.pdf';
  779.             $response = $this->getResponse($content, $filename);
  780.         }
  782.         return $response;
  783.     }
  785.     #[Route(path: '/api/conges/status/list', name: 'ctsweb_conges_status-list-pdf', methods: ['GET'], requirements: ['id' => '\d+'])]
  786.     public function statusList(): JsonResponse
  787.     {
  788.         $entityManager = $this->doctrine->getManager();
  790.         $statuses = $entityManager
  791.             ->getRepository(Workflow::class)
  792.             ->findBy(['idWorkflow' => Workflow::FILTER]);
  794.         return new JsonResponse(
  795.             $this->serialize($statuses),
  796.             JsonResponse::HTTP_OK,
  797.             [],
  798.             true
  799.         );
  800.     }
  802.     /**
  803.      * @return \Symfony\Component\Form\FormInterface
  804.      */
  805.     private function handleRequest(
  806.         Request $request,
  807.         Conge $conge,
  808.         string $label,
  809.         string $validationGroup
  810.     ) {
  811.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  812.         if (isset($data['pieceMotif'])) {
  813.             $data['pieceMotif'] = json_encode($data['pieceMotif'], JSON_THROW_ON_ERROR);
  814.         }
  815.         $request->request->replace(is_array($data) ? $data : []);
  817.         $form = $this->createForm(
  818.             CongeType::class,
  819.             $conge,
  820.             ['label' => $label, 'validation_groups' => $validationGroup]
  821.         );
  823.         $form->handleRequest($request);
  825.         return $form;
  826.     }
  828.     /**
  829.      * @param array $states
  830.      * @return mixed
  831.      */
  832.     private function serializeto($item)
  833.     {
  834.         $data = [$item];
  836.         $context = new SerializationContext();
  837.         $context->setSerializeNull(true);
  839.         return $this->serializer->serialize($data, 'json', $context);
  840.     }
  841.     /**
  842.      * @param array $states
  843.      * @return mixed
  844.      */
  845.     private function serialize($item)
  846.     {
  847.         $data = ["items" => $item];
  849.         $context = new SerializationContext();
  850.         $context->setSerializeNull(true);
  852.         return $this->serializer->serialize($data, 'json', $context);
  853.     }
  854.     /**
  855.      * @return object
  856.      */
  857.     private function getServiceAccessRule()
  858.     {
  859.         return $this->accessRule;
  860.     }
  862.     private function setWorkflow(Conge $conge)
  863.     {
  864.         $workflow = Workflow::CO_REJECT;
  866.         if ($conge->getResponse()) {
  867.             $workflow = Workflow::CO_ACCEPTED;
  868.         }
  870.         $entityManager = $this->doctrine->getManager();
  872.         $workflowEntity = $entityManager
  873.             ->getRepository(Workflow::class)
  874.             ->find($workflow);
  876.         $conge->setWorkflow($workflowEntity);
  877.     }
  879.     public function getResponse(string $content, string $filename): Response
  880.     {
  881.         return new Response(
  882.             $content,
  883.             Response::HTTP_OK,
  884.             [
  885.                 'Content-Type' => 'application/pdf',
  886.                 'Content-Length' => strlen($content),
  887.                 'Content-Disposition' => "attachment;filename=\"{$filename}",
  888.                 'Accept-Ranges' => 'bytes'
  889.             ]
  890.         );
  891.     }
  894.     /**
  895.      * @return JsonResponse
  896.      */
  897.     #[Route(path: '/api/calendrier-conges-info', name: 'ctsweb_calendrier-conges-info', methods: ['GET'])]
  898.     public function getCalendrierConges()
  899.     {
  900.         try {
  902.             $utilisateurInformation = $this->getUser();
  903.             $affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  904.             $entityManager = $this->doctrine->getManager();
  906.             $affectionEntity = $entityManager
  907.                 ->getRepository(RefAffectation::class)
  908.                 ->findOneBy(["idAffectation" => $affectation]);
  910.             // $dateBascule = $affectionEntity->getDateBascule();
  911.             $today = new \DateTime();
  912.             $today = $today->format('Y-m-d');
  914.             $getRefCalendrier =  $entityManager
  915.                 ->getRepository(RefAffectationCalendrier::class)
  916.                 ->getRefCalendrier($affectation);
  917.             $calendrier = $getRefCalendrier['calendrierAffectation'];
  918.             $getCheckbox =  $entityManager
  919.                 ->getRepository(RefAffectationCalendrier::class)
  920.                 ->findLastByRefAffectationId($affectation);
  921.             if (isset($getCheckbox['0']) && !empty($getCheckbox['0'])) {
  922.                 $Checkbox  =  $getCheckbox['0']['calendrier_scolaire'];
  923.             } else {
  924.                 $Checkbox  =  false;
  925.             }
  926.             $data = ["data" => ["calendrier_scolaire" => $calendrier, "calendrier_checkbox" => $Checkbox]];
  927.             $data = json_encode($data);
  928.             return new JsonResponse($data, JsonResponse::HTTP_OK, [], true);
  929.         } catch (\Exception $e) {
  930.             echo $e->getMessage();
  931.             $result = [
  932.                 'success' => false,
  933.                 'data' => self::ERROR_OCCURED
  934.             ];
  935.             return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  936.         }
  937.     }
  939.     /**
  940.      * @return JsonResponse
  941.      */
  942.     #[Route(path: '/api/calendrier-conges-info-form', name: 'ctsweb_calendrier-conges-info-form', methods: ['GET'])]
  943.     public function getCalendrierCongesForm()
  944.     {
  945.         try {
  946.             $utilisateurInformation = $this->getUser();
  947.             $affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  948.             $entityManager = $this->doctrine->getManager();
  950.             $getRefCalendrier =  $entityManager
  951.                 ->getRepository(RefAffectationCalendrier::class)
  952.                 ->getRefCalendrier($affectation);
  953.             $calendrier = $getRefCalendrier['calendrierAffectation'];
  955.             $data = ["data" => ["calendrier_scolaire" => $calendrier]];
  956.             $data = json_encode($data);
  957.             return new JsonResponse($data, JsonResponse::HTTP_OK, [], true);
  958.         } catch (\Exception $e) {
  959.             echo $e->getMessage();
  960.             $result = [
  961.                 'success' => false,
  962.                 'data' => self::ERROR_OCCURED
  963.             ];
  964.             return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  965.         }
  966.     }
  968.     #[Route(path: '/api/calendrier-conges', name: 'ctsweb_calendrier-conges', methods: ['POST'])]
  969.     // ...
  970.     public function changerRefAffectationCalendrier(Request $request)
  971.     {
  972.         try {
  973.             $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  974.             $request->request->replace(is_array($data) ? $data : []);
  975.             $params = $request->request->all();
  976.             $utilisateurInformation = $this->getUser();
  977.             $affectation = $utilisateurInformation->getIdAffectation();
  978.             $entityManager = $this->doctrine->getManager();
  979.             $aujourdhui = new \DateTime();
  980.             $refAffectationCalendrier = new RefAffectationCalendrier();
  981.             $refAffectationCalendrier->setIdAff($affectation->getIdAffectation());
  982.             $today = (new \DateTime());
  983.             $refAffectationCalendrierRepository = $entityManager->getRepository(RefAffectationCalendrier::class);
  984.             $currentYear = $today->format("Y");
  985.             $nextYear = $currentYear + 1;
  986.             $lastbascule = $refAffectationCalendrierRepository->findLastByRefAffectationId($affectation->getIdAffectation());
  987.             if (isset($lastbascule[0]) && !empty($lastbascule[0])) {
  988.                 $lastbasculeCalendrier = isset($lastbascule[0]['calendrier_scolaire']) ? $lastbascule[0]['calendrier_scolaire'] : '';
  989.             } else {
  990.                 $lastbasculeCalendrier = false;
  991.             }
  992.             if ($params["calendrier_scolaire"]) {
  994.                 if (!$lastbasculeCalendrier) {
  995.                     // Si nous sommes après le 1er septembre, fixer la date de bascule au 1er septembre de l'année prochaine
  996.                     if ($aujourdhui >= new \DateTime('first day of September')) {
  997.                         $dateBascule = new \DateTime('first day of September next year');
  998.                         $refAffectationCalendrier->setCalendrierScolaire(true);
  999.                         $refAffectationCalendrier->setDateBascule($dateBascule);
  1000.                         // Fixer la date de début au lendemain de la date de bascule
  1001.                         $refAffectationCalendrier->setDateDebut($dateBascule);
  1002.                         // Sauvegarder l'objet $RefAffectationCalendrier dans la base de données (EntityManager) pour suivre les changements de RefAffectationCalendrier.
  1003.                         $entityManager->persist($refAffectationCalendrier);
  1004.                         $entityManager->flush();
  1005.                     } else {
  1006.                         if (isset($lastbascule[0]) && !empty($lastbascule[0])) {
  1007.                             $datebasculeCalendrier = $lastbascule[0]['date_bascule'];
  1008.                             // $datebasculeCalendrier = $datebasculeCalendrier->format('Y-m-d');
  1009.                         } else {
  1010.                             $datebasculeCalendrier = false;
  1011.                         }
  1013.                         if ($datebasculeCalendrier  < new \DateTime('first day of September')) {
  1014.                             // Vérifier si la dernière ligne correspond à un type d'affectation spécifique
  1015.                             $dateBascule = new \DateTime('first day of September');
  1016.                             $isLastLineForSpecificAffectation = $refAffectationCalendrierRepository->findLastByRefAffectationIdcivile($affectation->getIdAffectation(), $dateBascule);
  1017.                             if (!$isLastLineForSpecificAffectation) {
  1018.                                 $dateBascule = new \DateTime('first day of September');
  1019.                                 $refAffectationCalendrier->setCalendrierScolaire(true);
  1020.                                 $refAffectationCalendrier->setDateBascule($dateBascule);
  1021.                                 // Fixer la date de début au lendemain de la date de bascule
  1022.                                 $refAffectationCalendrier->setDateDebut($dateBascule);
  1023.                                 // Sauvegarder l'objet $RefAffectationCalendrier dans la base de données (EntityManager) pour suivre les changements de RefAffectationCalendrier.
  1024.                                 $entityManager->persist($refAffectationCalendrier);
  1025.                                 $entityManager->flush();
  1026.                             }
  1027.                         } else {
  1028.                             // SUPPRIMER LE CALENDRIER 
  1030.                             if (isset($lastbascule[0]['id']) && !empty($lastbascule[0]['id'])) {
  1031.                                 // var_dump($lastbascule[0]['id']);
  1032.                                 $this->deleteByIdRefAffectation($lastbascule[0]['id']);
  1033.                             }
  1034.                         }
  1035.                     }
  1036.                 }
  1037.             } else {
  1039.                 $dateBascule = new \DateTime('first day of January next year');
  1040.                 $isLastLineForSpecificAffectation = $refAffectationCalendrierRepository->findLastByRefAffectationIdcivile($affectation->getIdAffectation(), $dateBascule);
  1041.                 $isLineForSpecificAffectation = $refAffectationCalendrierRepository->findLastByRefAffectationId($affectation->getIdAffectation());
  1042.                 if (!$isLastLineForSpecificAffectation &&  $isLineForSpecificAffectation) {
  1043.                     // Si nous sommes après le 1er janvier, fixer la date de bascule au 1er janvier de l'année prochaine
  1044.                     if ($aujourdhui >= new \DateTime('first day of January')) {
  1045.                         $dateBascule = new \DateTime('first day of January next year');
  1046.                         $refAffectationCalendrier->setCalendrierScolaire(false);
  1047.                         $refAffectationCalendrier->setDateBascule($dateBascule);
  1048.                         $date_debut = $dateBascule;
  1049.                         $refAffectationCalendrier->setDateDebut($date_debut);
  1050.                         // Sauvegarder l'objet $RefAffectationCalendrier dans la base de données (EntityManager) pour suivre les changements de RefAffectationCalendrier.
  1051.                         $entityManager->persist($refAffectationCalendrier);
  1052.                         $entityManager->flush();
  1053.                     }
  1054.                 }
  1055.             }
  1057.             $data = ['success' => true, 'data' => 'Mise à jour effectuée avec succès'];
  1059.             return new JsonResponse($data);
  1060.         } catch (\Exception $e) {
  1061.             echo $e->getMessage();
  1062.             $data = [
  1063.                 'success' => false,
  1064.                 'data' => self::ERROR_OCCURED
  1065.             ];
  1066.         }
  1068.         return new JsonResponse($data, JsonResponse::HTTP_BAD_REQUEST);
  1069.     }
  1070.     public function deleteByIdRefAffectation($id)
  1071.     {
  1072.         $entityManager = $this->doctrine->getManager();
  1073.         $entity = $entityManager->getRepository(RefAffectationCalendrier::class)->findOneBy(['id' => $id]);
  1075.         if ($entity) {
  1076.             $entityManager->remove($entity);
  1077.             $entityManager->flush();
  1078.             return true;
  1079.         }
  1081.         return false;
  1082.     }
  1085.     public function initSignatureConges($idconges)
  1086.     {
  1087.         try {
  1088.             // $listeConges =   explode(',', $request->request->get('listeConges'));
  1089.             // $listeConges = json_decode($request->getContent(), true);
  1090.             $em = $this->doctrine->getManager();
  1091.             $congesRepo = $em->getRepository(Conge::class);
  1092.             $workflow = $em->getRepository(Workflow::class)->find(Workflow::CO_SIGN);
  1093.             $jourdhui = (new \DateTime())->format('Y-m-d');
  1094.             $utilisateurRepository = $em->getRepository(Utilisateur::class);
  1095.             $congObj = $congesRepo->find($idconges);
  1096.             $idUtilisateur = $congObj->getUtilisateur()->getIdUtilisateur();
  1097.             $idSignataire = $this->getUser()->getUtilisateur()->getIdUtilisateur();
  1098.             $affectationSignataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idSignataire)->getIdAffectation()->getIdAffectation();
  1099.             $affectation = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idUtilisateur)->getIdAffectation()->getIdAffectation();
  1100.             
  1101.             // TODO: Valider la logique de sélection du signataire en fonction de l'affectation.
  1102.             /*  if ($affectationSignataire == $affectation) {
  1103.                 $signataire = $em->getRepository(UtilisateurInformation::class)->findOneBy(['utilisateur' =>$idSignataire]);
  1104.             }
  1105.             else {
  1106.                 if ($affectation != 1) {
  1107.                     $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDrSuperieur($affectation);
  1108.                 } else {
  1109.                     $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDsSuperieur($affectation);
  1110.                 }
  1111.                 $signataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($drsignataire);
  1112.             }*/
  1113.             if ($affectation != 1) {
  1114.                 $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDrSuperieur($affectation);
  1115.             } else {
  1116.                 $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDsSuperieur($affectation);
  1117.             }
  1118.             $signataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($drsignataire);
  1119.             
  1120.             $path = $signataire->getScan() ? $this->getParameter('dir_file_signature') . $signataire->getScan()->getAbsolutePath() : '';
  1122.             if ($path && file_get_contents($path)) {
  1123.                 $pathvrai = $path;
  1124.             } else {
  1125.                 $pathvrai = "";
  1126.             }
  1127.             $info_signature = array(
  1128.                 'nom' => $signataire->getNom(),
  1129.                 'prenom' => $signataire->getPrenom(),
  1130.                 'dateSignature' => date("d/m/Y"),
  1131.                 'sup' => true,
  1132.                 'fonction' => $signataire->getFonction(),
  1133.                 'path' =>  $pathvrai,
  1134.                 'civilite' => $signataire->getCivilite()
  1135.             );
  1136.             
  1137.             //  foreach ($listeConges as $conge) {
  1138.             $congObj = $congesRepo->find($idconges);
  1139.             $congObj->setWorkflow($workflow);
  1140.             $idUtilisateur = $congObj->getUtilisateur()->getIdUtilisateur();
  1141.             // $email = $utilisateurRepository->findCourrielById($idUtilisateur)[0]['courriel'];
  1142.             $emails = $utilisateurRepository->findCourrielById($idUtilisateur);
  1143.             $email = isset($emails[0]['courriel']) ? $emails[0]['courriel'] : null;
  1144.             // }
  1145.             $beginDate = $congObj->getDateDebut();
  1146.             $mail = $this->emailSHDecision->getMail(
  1147.                 EmailSHDecision::SIGNED,
  1148.                 EmailSHDecision::CONGE,
  1149.                 $email,
  1150.                 $beginDate
  1151.             );
  1152.             if ($mail) {
  1153.                 $this->mailer->send($mail);
  1154.             }
  1155.             // $info_signature['dateSignature']=$congObj->getDateDerniereModification();
  1156.             //  $em->setDateDeSignature($jourdhui);
  1157.             //  $em->setSignataire($signataire);
  1158.             $em->persist($congObj);
  1159.             $em->flush();
  1160.             $this->generatePdf->generatePdf($congObj, false, $affectation, $info_signature);
  1162.             $message = 'Tous les conges ont été signés avec succès.';
  1163.             $return = array(
  1164.                 'success' => true,
  1165.                 'data' => $message
  1166.             );
  1167.         } catch (\Exception $e) {
  1168.             $message = 'Un ou plusieurs congés n\'ont pu être signés.';
  1169.             $return = array(
  1170.                 'success' => false,
  1171.                 'data' => $e->getMessage()
  1172.             );
  1173.         }
  1174.         return new JsonResponse(
  1175.             $return,
  1176.             JsonResponse::HTTP_CREATED
  1177.         );
  1178.     }
  1180.     private function getChevalConge($conge,  $Idaffectation)
  1181.     {
  1182.         $entityManager = $this->doctrine->getManager();
  1183.         $today = (new \DateTime());
  1184.         $year = $today->format("Y");
  1185.         $getRefCalendrier =  $entityManager
  1186.             ->getRepository(RefAffectationCalendrier::class)
  1187.             ->getRefCalendrier($Idaffectation);
  1188.         $dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
  1189.         $congeScolaire = $getRefCalendrier['calendrierScolaire'];
  1190.         $today = (new \DateTime());
  1191.         $year = $today->format("Y");;
  1192.         if (!$congeScolaire) {
  1193.             if ($conge->getDateFin()->format('Y') != $conge->getDateDebut()->format('Y')) {
  1194.                 return false;
  1195.             }
  1196.         } else {
  1197.             if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
  1198.                 $annee = $year;
  1199.             } else {
  1200.                 $annee = $year + 1;
  1201.             }
  1202.             if ((int)$conge->getDateFin()->format('m') >=  9 && (int)$conge->getDateDebut()->format('m') <= 8) {
  1203.                 return false;
  1204.             }
  1205.         }
  1206.         return true;
  1207.     }
  1209.     private function getRequiredMotifOrPieceJointeForCexConge($conge)
  1210.     {
  1211.         $requiredFields = array();
  1212.         if ($conge->getCongeType()->getCode() == CongeTypes::CEX) {
  1213.             if ($conge->getMotifConge() == "") {
  1214.                 $requiredFields[] = "Le Motif de congé doit être renseigné";
  1215.             }
  1216.             if ($conge->getPieceMotif() == "") {
  1217.                 $requiredFields[] = "Vous devez joindre un justificatif ";
  1218.             }
  1219.         }
  1221.         return implode(" et ", $requiredFields);
  1222.     }
  1224.     #[Route(path: '/api/report-conge', name: 'ctsweb_calendrier-report', methods: ['POST'])]
  1225.     public function updateCalendrierReport(Request $request)
  1226.     {
  1227.         try {
  1228.             $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  1229.             $request->request->replace(is_array($data) ? $data : []);
  1230.             $params = $request->request->all();
  1233.             // Appeler la fonction pour mettre à jour les dates dans l'entité RefAffectation
  1234.             $this->updateDatesInRefAffectation($params);
  1236.             $data = ['success' => true, 'data' => 'Mise à jour effectuée avec succès'];
  1238.             return new JsonResponse($data);
  1239.         } catch (\Exception $e) {
  1240.             $data = [
  1241.                 'success' => false,
  1242.                 'data' =>  $e->getMessage()
  1243.             ];
  1244.         }
  1246.         return new JsonResponse($data, JsonResponse::HTTP_BAD_REQUEST);
  1247.     }
  1250.     /**
  1251.      * Met à jour les dates de l'entité RefAffectation avec les valeurs fournies.
  1252.      *
  1253.      * @param array $params Tableau contenant les dates à mettre à jour
  1254.      *
  1255.      * @throws \Exception Si une ou plusieurs des dates requises sont manquantes ou nulles
  1256.      */
  1257.     public function updateDatesInRefAffectation(array $params): void
  1258.     {
  1259.         // Vérifier si toutes les dates requises sont présentes et non nulles
  1260.         if (!$this->areDatesValid($params)) {
  1261.             throw new \Exception('Une ou plusieurs des dates requises sont manquantes ou nulles.');
  1262.         }
  1264.         // Créer des objets DateTime à partir des chaînes de dates
  1265.         $dateDebutCredit = new \DateTime($params['dateDebutCredit']);
  1266.         $dateFinCredit = new \DateTime($params['dateFinCredit']);
  1267.         $dateDebutDebit = new \DateTime($params['dateDebutDebit']);
  1268.         $dateFinDebit = new \DateTime($params['dateFinDebit']);
  1270.         $utilisateurInformation = $this->getUser();
  1271.         $affectation = $utilisateurInformation->getIdAffectation();
  1272.         $entityManager = $this->doctrine->getManager();
  1274.         $affectionEntity = $entityManager
  1275.             ->getRepository(RefAffectation::class)
  1276.             ->findOneBy(["idAffectation" => $affectation]);
  1278.         // Mettre à jour les propriétés de dates de l'entité
  1279.         $affectionEntity->setDateDebutCredit($dateDebutCredit);
  1280.         $affectionEntity->setDateFinCredit($dateFinCredit);
  1281.         $affectionEntity->setDateDebutDebit($dateDebutDebit);
  1282.         $affectionEntity->setDateFinDebit($dateFinDebit);
  1284.         $entityManager->persist($affectionEntity);
  1285.         $entityManager->flush();
  1286.     }
  1288.     /**
  1289.      * Vérifie si toutes les dates requises sont présentes, non nulles et valides.
  1290.      *
  1291.      * @param array $params Tableau contenant les dates à vérifier
  1292.      *
  1293.      * @return bool true si toutes les dates sont valides, false sinon
  1294.      * @throws \Exception Si une date est manquante, nulle, invalide ou si la date de début est supérieure ou égale à la date de fin
  1295.      */
  1296.     private function areDatesValid(array $params): bool
  1297.     {
  1298.         // Liste des dates requises
  1299.         $requiredDates = [
  1300.             'dateDebutCredit',
  1301.             'dateFinCredit',
  1302.             'dateDebutDebit',
  1303.             'dateFinDebit'
  1304.         ];
  1306.         // Vérifier si toutes les dates requises sont présentes, non nulles et valides
  1307.         foreach ($requiredDates as $dateKey) {
  1308.             if (!isset($params[$dateKey]) || empty($params[$dateKey])) {
  1309.                 throw new \Exception("La date '$dateKey' est manquante ou nulle.");
  1310.             }
  1312.             // Exclure la date '1970-01-01'
  1313.             if ($params[$dateKey] === '1970-01-01') {
  1314.                 throw new \Exception("La date '$dateKey' est invalide.");
  1315.             }
  1316.             // Vérifier le format de la date
  1317.             if (!strtotime($params[$dateKey])) {
  1318.                 throw new \Exception("La date '$dateKey' est invalide.");
  1319.             }
  1321.             // Créer l'objet DateTime
  1322.             $date = new \DateTime($params[$dateKey]);
  1324.             // Vérifier si l'objet DateTime a été créé avec succès
  1325.             if (!$date) {
  1326.                 throw new \Exception("La date '$dateKey' est invalide.");
  1327.             }
  1328.         }
  1330.         // Vérifier la relation entre les dates de début et de fin pour les crédits
  1331.         $dateDebutCredit = \DateTime::createFromFormat('Y-m-d', $params['dateDebutCredit']);
  1332.         $dateFinCredit = \DateTime::createFromFormat('Y-m-d', $params['dateFinCredit']);
  1333.         if ($dateDebutCredit > $dateFinCredit) {
  1334.             throw new \Exception("La date de début 'dateDebutCredit' doit être inférieure à la date de fin 'dateFinCredit'.");
  1335.         }
  1337.         // Vérifier la relation entre les dates de début et de fin pour les débits
  1338.         $dateDebutDebit = \DateTime::createFromFormat('Y-m-d', $params['dateDebutDebit']);
  1339.         $dateFinDebit = \DateTime::createFromFormat('Y-m-d', $params['dateFinDebit']);
  1340.         if ($dateDebutDebit > $dateFinDebit) {
  1341.             throw new \Exception("La date de début 'dateDebutDebit' doit être inférieure à la date de fin 'dateFinDebit'.");
  1342.         }
  1343.         // Débit report année antérieure >= Crédit report année antérieure
  1344.         if ($dateDebutDebit < $dateDebutCredit) {
  1345.             throw new \Exception("La date de début 'Date débit report année antérieure' doit être superieure ou égale  à la date de fin 'Date crédit report année antérieure'.");
  1346.         }
  1347.         return true;
  1348.     }
  1350.     /**
  1351.      * @return JsonResponse
  1352.      */
  1353.     #[Route(path: '/api/calendrier-report-info', name: 'ctsweb_calendrier-report-info', methods: ['GET'])]
  1354.     public function getCalendrierReport()
  1355.     {
  1356.         $jsonv = [];
  1357.         try {
  1358.             $utilisateurInformation = $this->getUser();
  1359.             $affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  1360.             $entityManager = $this->doctrine->getManager();
  1362.             $affectionEntity = $entityManager
  1363.                 ->getRepository(RefAffectation::class)
  1364.                 ->findOneBy(["idAffectation" => $affectation]);
  1366.             $getRefCalendrier =  $entityManager
  1367.                 ->getRepository(RefAffectationCalendrier::class)
  1368.                 ->getRefCalendrier($affectation);
  1369.             $calendrier = $getRefCalendrier['calendrierAffectation'];
  1371.             $anneeEnCours = date('Y'); // Récupère l'année en cours
  1373.             // Si $calendrier est faux, retourne l'année en cours
  1374.             // Sinon, retourne l'année précédente divisée par l'année en cours
  1375.             $annee = $calendrier ? ($anneeEnCours - 1) . '/' . $anneeEnCours : $anneeEnCours;
  1378.             // Récupère les dates 'dateDebutCredit', 'dateFinCredit', 'dateDebutDebit' et 'dateFinDebit' de $affectionEntity si elles existent
  1379.             $dateDebutCredit = isset($affectionEntity) ? $affectionEntity->getDateDebutCredit() : null;
  1380.             $dateFinCredit = isset($affectionEntity) ? $affectionEntity->getDateFinCredit() : null;
  1381.             $dateDebutDebit = isset($affectionEntity) ? $affectionEntity->getDateDebutDebit() : null;
  1382.             $dateFinDebit = isset($affectionEntity) ? $affectionEntity->getDateFinDebit() : null;
  1384.             // Crée le tableau items avec les valeurs récupérées
  1385.             $items = [
  1386.                 'annee' => $annee,
  1387.                 'dateDebutCredit' => isset($dateDebutCredit) ? $dateDebutCredit->format('Y-m-d H:i:s') : null,
  1388.                 'dateFinCredit' => isset($dateFinCredit) ? $dateFinCredit->format('Y-m-d H:i:s') : null,
  1389.                 'dateDebutDebit' => isset($dateDebutDebit) ? $dateDebutDebit->format('Y-m-d H:i:s') : null,
  1390.                 'dateFinDebit' => isset($dateFinDebit) ? $dateFinDebit->format('Y-m-d H:i:s') : null,
  1391.             ];
  1393.             $jsonv['items'] = $items;
  1395.             $json_merge = json_encode($jsonv);
  1397.             return new JsonResponse($json_merge, JsonResponse::HTTP_OK, [], true);
  1398.         } catch (\Exception $e) {
  1399.             // Gérer les exceptions
  1400.             return new JsonResponse(['error' => "Une erreur s'est produite."], JsonResponse::HTTP_INTERNAL_SERVER_ERROR);
  1401.         }
  1402.     }
  1404.     function createNewReport(): array
  1405.     {
  1407.         return [
  1408.             'dateDebut' => "-",
  1409.             'dateFin' => "-",
  1410.             'avisDtn' => "-",
  1411.             "congeType" => [
  1412.                 "id" => 6,
  1413.                 "libelle" => Workflow::STATETYPE[DemandeReport::TYPE_ONE],
  1414.                 "description" => null,
  1415.                 "code" => "DDR",
  1416.                 "nbJourTotal" => null,
  1417.                 "nouveauSolde" => null,
  1418.                 "solde" => null,
  1419.             ],
  1420.             'dateDebutType' =>  [
  1421.                 "libelle" => null,
  1422.                 "code" => null
  1423.             ],
  1424.             'dateFinType' => [
  1425.                 "libelle" => null,
  1426.                 "code" => null
  1427.             ],
  1428.             'isTooLate' => null,
  1429.             'motifConge' => null,
  1430.             'pieceMotif' => null,
  1431.             'commentaireSh' => null,
  1432.             'commentaireDtn' => null,
  1433.             'choixConge' => '2'
  1434.         ];
  1435.     }
  1437.     function createNewReportDtnSH(): array
  1438.     {
  1439.         return [
  1440.             'dateDebut' => "-",
  1441.             'dateFin' => "-",
  1442.             'avisDtn' => "-",
  1443.             "libelle" => Workflow::STATETYPE[DemandeReport::TYPE_ONE],
  1444.             "code" => "DDR",
  1445.             'dateDebutType' =>  null,
  1446.             'dateFinType' =>  null,
  1447.             'isTooLate' => null,
  1448.             'motifConge' => null,
  1449.             'pieceMotif' => null,
  1450.             'commentaireSh' => null,
  1451.             'commentaireDtn' => null,
  1452.             'choixConge' => '2'
  1453.         ];
  1454.     }
  1456.     function verifier_solde_comptes(Conge $conge)
  1457.     {
  1459.         $entityManager = $this->doctrine->getManager();
  1461.         $year = $this->getYear($conge);
  1462.         $utilisateurInformation = $this->getUser();
  1463.         $utilisateur = $utilisateurInformation->getUtilisateur();
  1465.         $recapitulatif = $entityManager
  1466.             ->getRepository(UtilisateurInformation::class)
  1467.             ->getInfos($utilisateur, $year);
  1468.         if ($conge->getCongeType()->getCode() == CongeTypes::CET) {
  1469.             $soldecompte = $recapitulatif['totalCet'] - $recapitulatif['givenCet'];
  1470.         } else {
  1471.             $soldecompte = $recapitulatif['totalReport'] - $recapitulatif['givenRaa'];
  1472.         }
  1473.         if ($soldecompte < $conge->getNbJour()) {
  1474.             return false;
  1475.         }
  1476.         return true;
  1477.     }
  1479.     public function getYear($conge)
  1480.     {
  1481.         $today = new \DateTime();
  1482.         $year = $today->format("Y");
  1483.         $utilisateur = $this->getUser()->getIdUtilisateur();
  1484.         $entityManager = $this->doctrine->getManager();
  1485.         $utilisateurInformation = $entityManager
  1486.             ->getRepository(UtilisateurInformation::class)
  1487.             ->findOneBy(["idUtilisateur" => $utilisateur]);
  1488.         if ($utilisateurInformation) {
  1489.             $idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  1491.             $affectation = $entityManager
  1492.                 ->getRepository(RefAffectation::class)
  1493.                 ->findOneBy(["idAffectation" => $idaffectation]);
  1494.             $getRefCalendrier =  $entityManager
  1495.                 ->getRepository(RefAffectationCalendrier::class)
  1496.                 ->getRefCalendrier($idaffectation);
  1497.             $calendrierScolaire = $getRefCalendrier['calendrierScolaire'];
  1498.             $dateBasculeCongeSolaire  = $getRefCalendrier['dateBascule'];
  1499.             if ($affectation) {
  1500.                 // $calendrierScolaire = $affectation->getCalendrierScolaire();
  1502.                 // $dateBasculeCong$dateBasculeCongeSolaire eSolaire = $affectation->getDateBascule();
  1503.                 if ((true === $calendrierScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
  1504.                     return $year - 1;
  1505.                 } else {
  1506.                     return $year;
  1507.                 }
  1508.             }
  1509.         }
  1511.         // Si l'année n'a pas pu être obtenue à partir de l'objet Utilisateur, on retourne l'année en cours
  1512.         return $year;
  1513.     }
  1515.     #[Route(path: '/api/send', name: 'ctsweb_sendEmail', methods: ['GET'])]
  1516.     public function sendTestEmail(MailerInterface $mailer)
  1517.     {
  1518.         chmod($this->getParameter('dir_file_rapport') . "RAA_2023_abboub_ali_vba.pdf", 0644);
  1519.         $attachmentPath = $this->getParameter('dir_file_rapport') . "RAA_2023_abboub_ali_vba.pdf";
  1521.         $email = (new Email())
  1522.             ->from('cts-web.assistance@sports.gouv.fr')
  1523.             ->to('dame.sall@soprasteria.com')
  1524.             ->subject('Test Email')
  1525.             ->text('This is a test email sent from Symfony 5.4.')
  1526.             //  ->attachFromPath( $this->getParameter('dir_file_rapport')."RAA_2023_abboub_ali_vba.pdf");
  1527.             ->attach(fopen($attachmentPath, 'r'));
  1528.         // ->attachFromPath($attachmentPath);
  1529.         $mailer->send($email);
  1531.         return new Response('Test email sent.');
  1532.     }
  1533. }