src/Controller/CongeDroitAnnuelController.php line 232

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\RefAffectationCalendrier;
  6. use JMS\Serializer\SerializationContext;
  7. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Symfony\Component\Routing\Annotation\Route;
  11. use App\Entity\Conge;
  12. use App\Entity\CongeDroitAnnuel;
  13. use App\Entity\CongeType;
  14. use App\Entity\Utilisateur;
  15. use App\Entity\UtilisateurInformation;
  16. use App\Entity\Workflow;
  17. use App\Form\CongeDroitAnnuelType;
  18. use Doctrine\Persistence\ManagerRegistry;
  19. use App\Services\AccessRule;
  20. use JMS\Serializer\SerializerInterface;
  21. use App\Entity\RefAffectation;
  22. use App\Entity\DemandeReport;
  24. class CongeDroitAnnuelController extends AbstractController
  25. {
  26.     private $doctrine;
  27.     private $accessRule;
  28.     private $serializer;
  29.     final public const ERROR_VALIDATION_FORM = 'Erreur lors de la validation du formulaire';
  30.     final public const ERROR_OCCURED = 'Une erreur est survenue';
  31.     final public const ERROR_ALREADY_EXISTS = 'Conge droit annuel déjà existant';
  32.     final public const ERROR_ACTION_FORBIDDEN = 'Action non autorisée';
  34.     public function __construct(ManagerRegistry $doctrine, AccessRule $accessRule, SerializerInterface $serializer)
  35.     {
  36.         $this->doctrine = $doctrine;
  37.         $this->accessRule = $accessRule;
  38.         $this->serializer = $serializer;
  39.     }
  41.     #[Route(path: '/api/conges-annuel/{id}', name: 'ctsweb_get_conges-annuel', methods: ['GET'], requirements: ['id' => '\d+'])]
  42.     public function detail(CongeDroitAnnuel $congeDroit): JsonResponse
  43.     {
  44.         $congeDroit = $this->serialize($congeDroit);
  46.         return new JsonResponse(
  47.             $congeDroit,
  48.             JsonResponse::HTTP_OK,
  49.             [],
  50.             true
  51.         );
  52.     }
  54.     /**
  55.      * @return JsonResponse
  56.      */
  57.     #[Route(path: '/api/conges-annuel', name: 'ctsweb_create_conges-annuel', methods: ['POST'])]
  58.     public function create(Request $request)
  59.     {
  61.         $congeAnnuel = new CongeDroitAnnuel();
  63.         $form = $this->handleRequest($request, $congeAnnuel, 'create');
  64.         $entityManager = $this->doctrine->getManager();
  65.         $utilisateur = $congeAnnuel->getUtilisateur();
  66.         $utilisateurInformation = $entityManager
  67.             ->getRepository(UtilisateurInformation::class)
  68.             ->findOneBy(["idUtilisateur" => $utilisateur]);
  69.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  70.         $today = (new \DateTime());
  71.         $year = $today->format("Y");
  72.         $getRefCalendrier =  $entityManager
  73.             ->getRepository(RefAffectationCalendrier::class)
  74.             ->getRefCalendrier($Idaffectation);
  76.         $congeScolaire = $getRefCalendrier['calendrierScolaire'];
  77.         $dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
  78.         $yearBascule = $getRefCalendrier['yearBascule'];
  79.         if ($dateBasculeCongeSolaire != null) {
  80.             if (intval($congeAnnuel->getAnnee()) >= intval($yearBascule)) {
  81.                 $typeCalendrier = ($congeScolaire) ? 's' : 'c';
  82.             } else {
  83.                 $typeCalendrier = ($congeScolaire) ? 'c' : 's';
  84.             }
  85.         } else {
  86.             $typeCalendrier = ($congeScolaire) ? 's' : 'c';
  87.         }
  88.         if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
  89.             $congeAnnuel->setAnnee($congeAnnuel->getAnnee() - 1);
  90.         }
  93.         if ($form->isSubmitted()) {
  94.             $entityManager = $this->doctrine->getManager();
  96.             $accessRuleService = $this->getServiceAccessRule();
  98.             if (!$accessRuleService->hasRightWithoutCheckAffectation($congeAnnuel->getUtilisateur(), $this->getUser())) {
  99.                 return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  100.             }
  102.             $congeAnnuelEntity = $entityManager
  103.                 ->getRepository(CongeDroitAnnuel::class)
  104.                 ->findOneBy([
  105.                     'annee' => $congeAnnuel->getAnnee(),
  106.                     'utilisateur' => $congeAnnuel->getUtilisateur(),
  107.                     'congeType' => $congeAnnuel->getCongeType(),
  108.                     'archive' => false
  109.                 ]);
  112.             if ($congeAnnuelEntity) {
  113.                 return new JsonResponse(
  114.                     [
  115.                         'success' => false,
  116.                         'info' => self::ERROR_ALREADY_EXISTS
  117.                     ],
  118.                     JsonResponse::HTTP_BAD_REQUEST
  119.                 );
  120.             }
  122.             $congeAnnuel->setArchive(false);
  123.             $congeAnnuel->setTypeCalendrier($typeCalendrier);
  125.             $entityManager->persist($congeAnnuel);
  126.             $entityManager->flush();
  128.             return new JsonResponse(
  129.                 [
  130.                     'success' => true
  131.                 ],
  132.                 JsonResponse::HTTP_CREATED
  133.             );
  134.         } else {
  136.             $result = [
  137.                 'success' => false,
  138.                 'data' => self::ERROR_VALIDATION_FORM,
  139.                 'error' => (string) $form->getErrors(true, false)
  140.             ];
  141.         }
  145.         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  146.     }
  148.     /**
  149.      * @return JsonResponse
  150.      */
  151.     #[Route(path: '/api/conges-annuel/{id}', name: 'ctsweb_update_conges-annuel', methods: ['POST'], requirements: ['id' => '\d+'])]
  152.     public function update(
  153.         Request $request,
  154.         CongeDroitAnnuel $congeAnnuel
  155.     ) {
  156.         $accessRuleService = $this->getServiceAccessRule();
  158.         if (!$accessRuleService->hasRightWithoutCheckAffectation($congeAnnuel->getUtilisateur(), $this->getUser())) {
  159.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  160.         }
  162.         $label = 'update-ca';
  164.         if ($congeAnnuel->getCongeType()->getCode() !== CongeType::CAN) {
  165.             $label = 'update-others';
  166.         }
  168.         $form = $this->handleRequest($request, $congeAnnuel, $label);
  170.         if ($form->isSubmitted() && $form->isValid()) {
  171.             $entityManager = $this->doctrine->getManager();
  173.             $entityManager->flush();
  175.             $result = ['success' => true];
  176.         } else {
  177.             $result = [
  178.                 'success' => false,
  179.                 'data' => self::ERROR_VALIDATION_FORM,
  180.                 'error' => (string) $form->getErrors(true, false)
  181.             ];
  182.         }
  184.         return new JsonResponse($result, JsonResponse::HTTP_OK);
  185.     }
  187.     /**
  188.      * @param CongeDroitAnnuel $id
  189.      */
  190.     #[Route(path: '/api/conges-annuel/delete/{id}/{utilisateur}', name: 'ctsweb_remove_conges-annuel', methods: ['POST'], requirements: ['id' => '\d+', 'utilisateur' => '\d+'])]
  191.     public function delete(
  192.         CongeDroitAnnuel $congeDroitAnnuel,
  193.         Utilisateur $utilisateur
  194.     ): JsonResponse {
  196.         if ($congeDroitAnnuel->getUtilisateur() !== $utilisateur) {
  197.             return new JsonResponse(
  198.                 ['info' => self::ERROR_ACTION_FORBIDDEN],
  199.                 JsonResponse::HTTP_FORBIDDEN
  200.             );
  201.         }
  202.         $this->doctrine->getManager()->remove($congeDroitAnnuel);
  203.         $this->doctrine->getManager()->flush();
  205.         return new JsonResponse('', JsonResponse::HTTP_NO_CONTENT);
  206.     }
  208.     #[Route(path: '/api/conges-annuel/search/{user}/{year}/{type}', name: 'ctsweb_get_conges-annuel-by-year-type-user', methods: ['GET'], requirements: ['user' => '\d+', 'year' => '\d+'])]
  209.     public function searchByUserAndUserAndType(
  210.         Utilisateur $user,
  211.         int $year,
  212.         string $type
  213.     ): JsonResponse {
  215.         $congeAnnuel = $this
  216.             ->doctrine
  217.             ->getRepository(CongeDroitAnnuel::class)
  218.             ->searchByUserAndUserAndType($user, $year, $type);
  220.         return new JsonResponse(
  221.             $this->serialize($congeAnnuel),
  222.             JsonResponse::HTTP_OK,
  223.             [],
  224.             true
  225.         );
  226.     }
  228.     /**
  229.      * @return JsonResponse
  230.      */
  231.     #[Route(path: '/api/conges-annuel/list/{conge}', name: 'ctsweb_list_conges-annuel_by_conge', methods: ['GET'], requirements: ['conge' => '\d+'])]
  232.     public function listByDayOff(Conge $conge)
  233.     {
  234.         $congeTypes = $this->doctrine
  235.             ->getRepository(CongeType::class)
  236.             ->findBy(['code' => ['RTT', 'CAN', 'RAA', 'CET']], ['id' => 'ASC']);
  238.         $utilisateurInformation = $this->getUser();
  239.         $affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  240.         $entityManager = $this->doctrine->getManager();
  241.         $getRefCalendrier =  $entityManager
  242.             ->getRepository(RefAffectationCalendrier::class)
  243.             ->getRefCalendrier($affectation);
  245.         $congeScolaire = $getRefCalendrier['calendrierScolaire'];
  246.         $dateBascule  = $getRefCalendrier['dateBascule'];
  248.         $today = (new \DateTime());
  250.         $currentYear = $today->format("Y");
  251.         $dateCalendrierScolaire = new \DateTime("$currentYear-09-01");
  253.         if (true === $congeScolaire) {
  254.             if ($conge->getDateDebut() < $dateCalendrierScolaire && $today < $dateCalendrierScolaire) {
  255.                 $year = $conge->getDateDebut()->format("Y");
  256.             } elseif ($conge->getDateDebut() < $dateCalendrierScolaire && $today > $dateCalendrierScolaire) {
  257.                 $year = $conge->getDateDebut()->format("Y") - 1;
  258.             } elseif ($conge->getDateDebut() > $dateCalendrierScolaire && $today < $dateCalendrierScolaire) {
  259.                 $year = $conge->getDateDebut()->format("Y") + 1;
  260.             } else {
  261.                 $year = $conge->getDateDebut()->format("Y");
  262.             }
  263.         } else {
  264.             $year = $conge->getDateDebut()->format("Y");
  265.         }
  267.         foreach ($congeTypes as $congeType) {
  269.             $congeType = $this->setTotal($conge->getUtilisateur(), $congeType, $year, $conge->getDateDebut(), $congeScolaire);
  271.             if ($congeType === $conge->getCongeType()) {
  272.                 $congeType->setNouveauSolde($congeType->getSolde() - $conge->getNbJour());
  273.             } else {
  274.                 $congeType->setNouveauSolde($congeType->getSolde());
  275.             }
  277.             if ((($dateBascule != null) && ($dateBascule < $today)) || ($dateBascule == null)) {
  278.                 $congeType->setCalendrierScolaire($congeScolaire);
  279.             } else {
  280.                 $congeType->setCalendrierScolaire(!$congeScolaire);
  281.             }
  282.         }
  284.         return new JsonResponse(
  285.             $this->serialize($congeTypes),
  286.             JsonResponse::HTTP_OK,
  287.             [],
  288.             true
  289.         );
  290.     }
  293.     //#[Route(path: '/api/conges-annuel/list/{conge}', name: 'ctsweb_list_conges-annuel_by_conge')]
  294.     public function getAnneeExportAction(Request $request)
  295.     {
  296.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  297.         $request->request->replace(is_array($data) ? $data : []);
  298.         $params = $request->request->all();
  299.     }
  304.     /**
  305.      * @return JsonResponse
  306.      */
  307.     #[Route(path: '/api/conges-annuel/recap/{utilisateur}/{year}', name: 'ctsweb_list_conges-annuel_by_user_year', methods: ['GET'], requirements: ['utilisateur' => '\d+', 'year' => '\d+'])]
  308.     public function recap(
  309.         Utilisateur $utilisateur,
  310.         int $year
  311.     ) {
  312.         $entityManager = $this->doctrine->getManager();
  313.         $utilisateurInformation = $entityManager
  314.             ->getRepository(UtilisateurInformation::class)
  315.             ->findOneBy(["idUtilisateur" => $utilisateur]);
  316.         $affectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  317.         $entityManager = $this->doctrine->getManager();
  319.         $affectionEntity = $entityManager
  320.             ->getRepository(RefAffectation::class)
  321.             ->findOneBy(["idAffectation" => $affectation]);
  323.         $getRefCalendrier =  $entityManager
  324.             ->getRepository(RefAffectationCalendrier::class)
  325.             ->getRefCalendrier($affectation);
  327.         $congeScolaire = $getRefCalendrier['calendrierScolaire'];
  328.         $congeTypes = $this->doctrine
  329.             ->getRepository(CongeType::class)
  330.             ->findBy(['code' => ['RTT', 'CAN', 'CET']], ['id' => 'ASC']);
  332.         foreach ($congeTypes as $congeType) {
  333.             $congeType = $this->setTotal($utilisateur, $congeType, $year, new \DateTime("$year-12-31"), $congeScolaire);
  334.         }
  338.         return new JsonResponse(
  339.             $this->serialize($congeTypes),
  340.             JsonResponse::HTTP_OK,
  341.             [],
  342.             true
  343.         );
  344.     }
  346.     /**
  347.      * @param Utilisateur $user
  348.      * @param $year
  349.      * @return JsonResponse
  350.      */
  351.     #[Route(path: '/api/conges-annuel/listing/{utilisateur}/{year}', name: 'ctsweb_list_conges-annuel', methods: ['GET'], requirements: ['utilisateur' => '\d+', 'year' => '\d+'])]
  352.     public function listByYearAndUser(Utilisateur $utilisateur, $year)
  353.     {
  354.         // détecter affectation et conge scolaire
  355.         $entityManager = $this->doctrine->getManager();
  356.         $utilisateurInformation = $entityManager
  357.             ->getRepository(UtilisateurInformation::class)
  358.             ->findOneBy(["idUtilisateur" => $utilisateur]);
  359.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  360.         $affectation = $entityManager
  361.             ->getRepository(RefAffectation::class)
  362.             ->findOneBy(["idAffectation" => $Idaffectation]);
  363.         // $congeScolaire = $affectation->getCalendrierScolaire();
  364.         // $dateBascule = $affectation->getDateBascule();
  365.         $today = new \DateTime();
  366.         $currentYear = $today->format("Y");
  368.         $getRefCalendrier =  $entityManager
  369.             ->getRepository(RefAffectationCalendrier::class)
  370.             ->getRefCalendrier($Idaffectation);
  372.         $congeScolaire = $getRefCalendrier['calendrierAffectation'];
  373.         $dateBascule = $getRefCalendrier['dateBascule'];
  374.         if ($congeScolaire) {
  376.             if ((null != $dateBascule) && ($today >= $dateBascule)) {
  378.                 if ($today < new \DateTime($currentYear . '-09-01')) {
  380.                     $congeAnnuel = $this->doctrine
  381.                         ->getRepository(CongeDroitAnnuel::class)
  382.                         ->findBy([
  383.                             'utilisateur' => $utilisateur,
  384.                             'annee' => $year - 1,
  385.                             'archive' => false,
  386.                             'congeType' => [1, 2, 3, 4]
  387.                         ], ['congeType' => 'ASC']);
  389.                     $congeCet = $this->doctrine
  390.                         ->getRepository(CongeDroitAnnuel::class)
  391.                         ->findBy([
  392.                             'utilisateur' => $utilisateur,
  393.                             'annee' => $year - 1,
  394.                             'archive' => false,
  395.                             'congeType' => 5
  396.                         ], ['congeType' => 'ASC']);
  398.                     $congeAnnuel = array_merge($congeAnnuel, $congeCet);
  399.                 } else {
  400.                     $year = $year;
  401.                     $congeAnnuel = $this->doctrine
  402.                         ->getRepository(CongeDroitAnnuel::class)
  403.                         ->findBy([
  404.                             'utilisateur' => $utilisateur,
  405.                             'annee' => $year,
  406.                             'archive' => false
  407.                         ], ['congeType' => 'ASC']);
  408.                 }
  409.             } else {
  410.                 $congeAnnuel = $this->doctrine
  411.                     ->getRepository(CongeDroitAnnuel::class)
  412.                     ->findBy([
  413.                         'utilisateur' => $utilisateur,
  414.                         'annee' => $year,
  415.                         'archive' => false
  416.                     ], ['congeType' => 'ASC']);
  417.             }
  418.         } else {
  419.             $congeAnnuel = $this->doctrine
  420.                 ->getRepository(CongeDroitAnnuel::class)
  421.                 ->findBy([
  422.                     'utilisateur' => $utilisateur,
  423.                     'annee' => $year,
  424.                     'archive' => false
  425.                 ], ['congeType' => 'ASC']);
  426.         }
  428.         return new JsonResponse(
  429.             $this->serialize($congeAnnuel),
  430.             JsonResponse::HTTP_OK,
  431.             [],
  432.             true
  433.         );
  434.     }
  439.     /**
  440.      * @return JsonResponse
  441.      */
  442.     #[Route(path: '/api/conges-droits-annees/{id}', name: 'ctsweb_conges-annuel-annees', methods: ['GET'], requirements: ['id' => '\d+'])]
  443.     public function getAnnees(
  444.         int $id
  446.     ) {
  447.         $entityManager = $this->doctrine->getManager();
  448.         $congesDroitsAnnees = $entityManager
  449.             ->getRepository(CongeDroitAnnuel::class)
  450.             ->findAndOrderBy($id);
  451.         $utilisateurInformation = $entityManager
  452.             ->getRepository(UtilisateurInformation::class)
  453.             ->findOneBy(["idUtilisateur" => $id]);
  454.         $affectation = $utilisateurInformation->getIdAffectation();
  455.         $refcalendrier =  $entityManager
  456.             ->getRepository(RefAffectationCalendrier::class)
  457.             ->findAllByRefAffectation($affectation->getIdAffectation());
  459.         $getRefCalendrier =  $entityManager
  460.             ->getRepository(RefAffectationCalendrier::class)
  461.             ->getRefCalendrier($affectation->getIdAffectation());
  462.         $congeScolaireAffectation = $getRefCalendrier['calendrierScolaire'];
  463.         $dateBascule  = $getRefCalendrier['dateBascule'];
  465.         $today = new \DateTime();
  466.         $today = $today->format('Y-m-d');
  468.         $congesDroitsAnnees = $this->manageYears(
  469.             $id,
  470.             $congeScolaireAffectation,
  471.             $dateBascule,
  472.             $today,
  473.             $congesDroitsAnnees,
  474.             $refcalendrier
  475.         );
  476.         return new JsonResponse(
  477.             $this->serialize($congesDroitsAnnees),
  478.             JsonResponse::HTTP_OK,
  479.             [],
  480.             true
  481.         );
  482.     }
  483.     public  function createYearLabels($records, $id)
  484.     {
  485.         // Récupérer toutes les dates de bascule dans un tableau
  486.         $basculeDates = array_column($records, 'date_bascule');
  488.         // Trier les dates de bascule par ordre croissant
  489.         sort($basculeDates);
  491.         // Obtenir l'année actuelle
  492.         $currentYear = $this->anneeMax($basculeDates);
  493.         $currentYears = date('Y');
  494.         $aujourdhui = new \DateTime();
  495.         $currentDay = $aujourdhui->format('Y-m-d');
  496.         // Créer un tableau pour stocker les libellés
  497.         $yearLabels = array();
  498.         if (empty($currentYear)) {
  500.             for ($year = 2021; $year <= $currentYears; $year++) {
  501.                 $archive = ($year == 2021) ? 1 : 0;
  502.                 $type_calendrier = 'c';
  503.                 $yearLabels[] = array('libelle' => $year, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $year);
  504.             }
  505.         } else {    
  506.               // Vérifier si l'année 2021 doit être incluse
  507.             for ($year = 2021; $year <=  $currentYears; $year++) {
  508.                 $archive = ($year == 2021) ? 1 : 0;
  509.                 if (in_array($year . '-01-01', $basculeDates) || $year == 2021) {
  510.                     $type_calendrier = 'c';
  511.                     $yearLabels[] = array('libelle' => $year, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $year);
  512.                 } else {
  513.                     $label = $year;
  514.                     $nextYear = $year + 1;
  515.                     $prevYear = $year - 1;
  517.                     if (in_array($year . '-09-01', $basculeDates)) {
  518.                         $type_calendrier = 'c';
  519.                         $yearLabels[] = array('libelle' => $label, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $prevYear . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $prevYear);
  520.                         $label .= '/' . $nextYear;
  521.                         // }
  522.                         $type_calendrier = 's';
  524.                         $yearLabels[] = array('libelle' => $label, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $year);
  525.                     }
  526.                     elseif(($currentDay > $year . '-09-01')){
  527.                         $label .= '/' . $nextYear;
  528.                         $type_calendrier = 's';
  530.                         $yearLabels[] = array('libelle' => $label, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $year);
  531.          
  532.                     }
  533.                   
  534.                 }
  535.             }
  536.         }
  537.         if (!empty($basculeDates)) {
  538.             $maxDate = max($basculeDates);
  539.             $currentYear = $this->anneeMax($maxDate);
  540.             if ($aujourdhui >= new \DateTime('first day of September') && ($this->isSeptemberFirst($maxDate))) {
  542.                 for ($year =  $currentYear + 1; $year <=  date('Y'); $year++) {
  543.                     $archive = ($year == 2021) ? 1 : 0;
  544.                     $label = $year;
  545.                     $nextYear = $year + 1;
  546.                     $type_calendrier = 's';
  547.                     $label .= '/' . $nextYear;
  548.                     $yearLabels[] = array('libelle' => $label, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive, 'type_calendrier' => $type_calendrier, 'year_url' => $year);
  549.                 }
  550.             }
  551.             // else {
  552.             //     $archive = ($year == 2021) ? 1 : 0;
  554.             //     for ($year =  $currentYear; $year <=  date('Y'); $year++) {
  555.             //         $label = $year;
  556.             //         $type_calendrier = 'c';
  557.             //         $yearLabels[] = array('libelle' => $label, 'annee' => $year, 'archive' => $archive, 'url' => "api/conges-droits-annees-export/" . $id . "/" . $year . "/" . $type_calendrier . "/" . $archive,'type_calendrier'=>$type_calendrier);
  558.             //     }
  559.             // }
  560.         }
  561.         return $yearLabels;
  562.     }
  563.     function isSeptemberFirst($date)
  564.     {
  565.         $dateToCheck = '09-01';
  566.         $formattedDate = date('m-d', strtotime($date));
  567.         return ($formattedDate === $dateToCheck);
  568.     }
  569.     public  function anneeMax($dates)
  570.     {
  571.         $maxYear = null;
  573.         foreach ((array) $dates as $date) {
  574.             $year = intval(substr($date, 0, 4));
  575.             if ($maxYear === null || $year > $maxYear) {
  576.                 $maxYear = $year;
  577.             }
  578.         }
  580.         return $maxYear;
  581.     }
  586.     public function manageYears(
  587.         $id,
  588.         $congeScolaire,
  589.         $dateBascule,
  590.         $today,
  591.         $congesDroitsAnnees,
  592.         $refcalendrier
  593.     ) {
  594.         $todays = new \DateTime();
  595.         $currentYear = $todays->format('Y');
  596.         $delete = false;
  597.         foreach ($congesDroitsAnnees as $key => $congesDroitsAnnee) {
  598.             if ($today < $currentYear . '-09-01'  && (true == $congeScolaire) &&  $congesDroitsAnnee['annee'] == $currentYear) {
  599.                 unset($congesDroitsAnnees[$key]);
  600.             }
  601.             if ($congesDroitsAnnee['annee'] == 2021 && (false == $congeScolaire)) {
  602.                 if ($delete) {
  603.                     unset($congesDroitsAnnees[$key]);
  604.                 }
  605.                 $delete = true;
  606.             }
  607.         }
  608.         return $this->createYearLabels($refcalendrier, $id);
  609.     }
  613.     #[Route(path: '/api/conges-droits-annees-affectation/{idAff}', name: 'ctsweb_conges-annuel-annees-affectation', methods: ['GET'], requirements: ['id' => '\d+'])]
  615.     public function getAnneesAffectation(
  616.         int $idAff
  618.     ) {
  619.         $entityManager = $this->doctrine->getManager();
  621.         if ($idAff != 1) {
  622.             $usersByAffectation = $entityManager
  623.                 ->getRepository(UtilisateurInformation::class)
  624.                 ->findBy(["idAffectation" => $idAff]);
  625.         } else {
  626.             $usersByAffectation = $entityManager
  627.                 ->getRepository(UtilisateurInformation::class)
  628.                 ->findAll();
  629.         }
  630.         $i = 0;
  631.         $output = [];
  633.         $affectation = $entityManager
  634.             ->getRepository(RefAffectation::class)
  635.             ->findOneBy(["idAffectation" => 1]);
  637.         foreach ($usersByAffectation as $userByAffectation) {
  638.             $id = $userByAffectation->getIdUtilisateur();
  639.             $congesDroitsAnnees = $entityManager
  640.                 ->getRepository(CongeDroitAnnuel::class)
  641.                 ->findAndOrderBy($id);
  643.             $utilisateurInformation = $entityManager
  644.                 ->getRepository(UtilisateurInformation::class)
  645.                 ->findOneBy(["idUtilisateur" => $id]);
  647.             /** Fix Err 500 prod sur $utilisateurInformation null bouton syntheses archivées**/
  648.             if (null !== $utilisateurInformation) {
  649.                 if (null != $utilisateurInformation->getIdAffectation()) {
  650.                     $affectation = $utilisateurInformation->getIdAffectation();
  651.                 }
  652.             }
  653.             $refcalendrier =  $entityManager
  654.                 ->getRepository(RefAffectationCalendrier::class)
  655.                 ->findAllByRefAffectation($affectation->getIdAffectation());
  656.             $tableaubascule = $entityManager
  657.                 ->getRepository(RefAffectationCalendrier::class)
  658.                 ->getClosestDates($refcalendrier);
  659.             if (isset($tableaubascule) &&  !empty($tableaubascule)) {
  660.                 $congeScolaire  = $tableaubascule[0]['calendrier_scolaire'];
  661.                 $dateBascule = $tableaubascule[0]['date_bascule'];
  662.             } else {
  663.                 $congeScolaire  = false;
  664.                 $dateBascule = null;
  665.             }
  666.             $today = new \DateTime();
  667.             $today = $today->format('Y-m-d');
  670.             $congesDroitsAnneesAffectation[$i] = $this->manageYears(
  671.                 $id,
  672.                 $congeScolaire,
  673.                 $dateBascule,
  674.                 $today,
  675.                 $congesDroitsAnnees,
  676.                 $refcalendrier
  678.             );
  679.             foreach ($congesDroitsAnneesAffectation[$i] as $congesDroitsAnneesAffectationArr) {
  680.                 unset($congesDroitsAnneesAffectationArr["url"]);
  681.                 $congesDroitsAnneesAffectation["id_user"] = $id;
  682.                 $congesDroitsAnneesAffectation[$i][] = $congesDroitsAnneesAffectationArr;
  683.                 $output[] = $congesDroitsAnneesAffectationArr;
  684.             }
  686.             $i++;
  687.         }
  688.         $output = array_unique($output, SORT_REGULAR);
  689.         if ($idAff != 1) {
  690.             $valsort = array_column($output, 'libelle');
  691.             foreach ($output as $key => $congesDroitsAnneesAffectationItem) {
  693.                 if (!empty($congesDroitsAnneesAffectationItem)) {
  694.                     $archive = ($congesDroitsAnneesAffectationItem['archive']) ? 1 : 0;
  695.                     $congesDroitsAnneesAffectationItem['url'] = "api/export/conges/" . $idAff . "/" . $congesDroitsAnneesAffectationItem['year_url'] . "/" . $congesDroitsAnneesAffectationItem['type_calendrier'] . "/" . $archive;
  696.                     $output[$key] = $congesDroitsAnneesAffectationItem;
  697.                 } else {
  698.                     unset($output[$key]);
  699.                 }
  700.             }
  702.             array_multisort($valsort, SORT_ASC, $output);
  703.         } else {
  704.             $valsort = array_column($output, 'annee');
  705.             foreach ($output as $key => $congesDroitsAnneesAffectationItem) {
  707.                 if (!empty($congesDroitsAnneesAffectationItem)) {
  708.                     $congesDroitsAnneesAffectationItem["archive"] = 2;
  709.                     $congesDroitsAnneesAffectationItem["type_calendrier"] = "all";
  710.                     $congesDroitsAnneesAffectationItem["libelle"] = $congesDroitsAnneesAffectationItem["annee"];
  711.                     $congesDroitsAnneesAffectationItem['url'] = "api/export/conges/" . $idAff . "/" . $congesDroitsAnneesAffectationItem['year_url'] . "/" . $congesDroitsAnneesAffectationItem['type_calendrier'] . "/" . $congesDroitsAnneesAffectationItem["archive"];
  712.                     $output[$key] = $congesDroitsAnneesAffectationItem;
  713.                 } else {
  714.                     unset($output[$key]);
  715.                 }
  716.             }
  717.             array_multisort($valsort, SORT_ASC, $output);
  718.             $output = $this->getTableauParAnneeSansDoublon($output);
  719.         }
  720.         $output = array_unique($output, SORT_REGULAR);
  721.         $return = [];
  722.         foreach ($output as $key => $value) {
  723.             $return[] = $value;
  724.         }
  725.         return new JsonResponse(
  726.             $this->serialize($return),
  727.             JsonResponse::HTTP_OK,
  728.             [],
  729.             true
  730.         );
  731.     }
  733.     public function getTableauParAnneeSansDoublon($tableau)
  734.     {
  735.         $result = array();
  736.         $anneesTraitees = array();
  738.         foreach ($tableau as $element) {
  739.             $annee = $element['url'];
  740.             if (!in_array($annee, $anneesTraitees)) {
  741.                 $result[] = $element;
  742.                 $anneesTraitees[] = $annee;
  743.             }
  744.         }
  746.         return $result;
  747.     }
  749.     /**
  750.      * @return JsonResponse
  751.      */
  752.     #[Route(path: '/api/conges-droits-saisie-annee/{id}/{n}', name: 'ctsweb_conges-saisie-annees', methods: ['GET'], requirements: ['id' => '\d+'])]
  753.     public function getAnneeSaisie(
  754.         int $id,
  755.         int $n
  756.     ) {
  758.         $congesDroitsAnnees = [];
  759.         $entityManager = $this->doctrine->getManager();
  761.         $utilisateurInformation = $entityManager
  762.             ->getRepository(UtilisateurInformation::class)
  763.             ->findOneBy(["idUtilisateur" => $id]);
  765.         $affectation = $utilisateurInformation->getIdAffectation();
  766.         // $congeScolaire = $affectation->getCalendrierScolaire();
  767.         // $dateBascule = $affectation->getDateBascule();
  768.         // if (null !== $dateBascule) {
  769.         //     $dateBascule = $dateBascule->format('Y-m-d');
  770.         // }
  771.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  773.         $today = new \DateTime();
  774.         $currentYear = $today->format('Y');
  775.         $getRefCalendrier =  $entityManager
  776.             ->getRepository(RefAffectationCalendrier::class)
  777.             ->getRefCalendrier($Idaffectation);
  779.         $congeScolaire = $getRefCalendrier['calendrierAffectation'];
  780.         $dateBascule = $getRefCalendrier['dateBascule'];
  781.         if ($n == 0) {
  782.             $year = $currentYear - 1;
  783.             $currentDay = $today;
  784.         } else {
  785.             $year = $currentYear;
  786.             $currentDay = $today;
  787.         }
  788.         $currentDay = $currentDay->format('Y-m-d');
  790.         $nextYear = $year + 1;
  791.         $lastYear = $year - 1;
  792.         if ((true == $congeScolaire) && (null != $dateBascule) && ($currentDay >= $dateBascule)) {
  793.             if ($n == 1) {
  794.                 $date = new \DateTime('first day of September');
  795.                 if ($currentDay < $date->format('Y-m-d')) {
  796.                     $congesDroitsAnnees['libelle'] =  $lastYear . "/" .  $year;
  797.                 } else {
  798.                     $congesDroitsAnnees['libelle'] =  $year  . "/" .  $nextYear;
  799.                 }
  800.             } else {
  801.                 $dateB = new \DateTime('first day of September');
  802.                 $formattedDate = $dateB->format('Y-m-d');
  803.                 if ($dateBascule < $formattedDate &&  ($currentDay > $dateB->format('Y-m-d')) ){
  804.                     $congesDroitsAnnees['libelle'] =  $year  . "/" .  $nextYear;
  805.                 }
  806.                 elseif($currentDay < $dateB->format('Y-m-d')){
  807.                         $congesDroitsAnnees['libelle'] = $lastYear . "/" .  $year;
  808.                 } else {
  809.                     $congesDroitsAnnees['libelle'] = strval($year);
  810.                    
  811.                 }
  812.             }
  813.             $congesDroitsAnnees['id'] = $id;
  814.         } elseif ((true == $congeScolaire) && (null != $dateBascule) && ($currentDay < $dateBascule)) {
  815.             $congesDroitsAnnees['libelle'] = strval($year);
  816.         } elseif ((false == $congeScolaire) && (null != $dateBascule) && ($currentDay <= $dateBascule)) {
  817.             $congesDroitsAnnees['libelle'] =   $lastYear . "/" . $year;
  818.         } else {
  819.             $congesDroitsAnnees['libelle'] = strval($year);
  820.         }
  822.         $congesDroitsAnnees['id'] = $id;
  823.         return new JsonResponse(
  824.             $this->serialize($congesDroitsAnnees),
  825.             JsonResponse::HTTP_OK,
  826.             [],
  827.             true
  828.         );
  829.     }
  833.     /**
  834.      * @return JsonResponse
  835.      */
  836.     #[Route(path: '/api/conges-annuel/recapitulatif/{conge}', name: 'ctsweb_manager_recap_conges-annuel', methods: ['GET'], requirements: ['conge' => '\d+'])]
  837.     public function managerRecap(Conge $conge)
  838.     {
  840.         $entityManager = $this->doctrine->getManager();
  841.         $utilisateur = $conge->getUtilisateur();
  842.         $utilisateurInformation = $entityManager
  843.             ->getRepository(UtilisateurInformation::class)
  844.             ->findOneBy(["idUtilisateur" => $utilisateur]);
  845.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  846.         $affectation = $entityManager
  847.             ->getRepository(RefAffectation::class)
  848.             ->findOneBy(["idAffectation" => $Idaffectation]);
  849.         // $congeScolaire = $affectation->getCalendrierScolaire();
  850.         $getRefCalendrier =  $entityManager
  851.             ->getRepository(RefAffectationCalendrier::class)
  852.             ->getRefCalendrier($Idaffectation);
  853.         $congeScolaire  = $getRefCalendrier['calendrierScolaire'];
  854.         $recapitulatif = $entityManager
  855.             ->getRepository(Conge::class)
  856.             ->getRecapitulatif($conge, $congeScolaire);
  857. // var_dump($recapitulatif);
  859.         $managerRecap = $this->manage($recapitulatif);
  860.         // var_dump($managerRecap);
  861.         // die();
  863.         return new JsonResponse(
  864.             $this->serialize($managerRecap),
  865.             JsonResponse::HTTP_OK,
  866.             [],
  867.             true
  868.         );
  869.     }
  872.     /**
  873.      * 
  874.      * @return JsonResponse
  875.      */
  877.     public function majDaysOffAction()
  878.     {
  880.         $entityManager = $this->doctrine->getManager();
  881.         $listAffectations = $entityManager->getRepository(RefAffectation::class)->findAll();
  882.         $array = [];
  883.         foreach ($listAffectations as $affectation) {
  885.             $today = new \DateTime('now');
  886.             $year = $today->format('Y');
  887.             $today = $today->format('Y-m-d');
  888.             if (null != $affectation->getDateBascule()) {
  889.                 $date_format = $affectation->getDateBascule()->format('Y-m-d');
  890.             } else {
  891.                 $date_format = $affectation->getDateBascule();
  892.             }
  894.             $array[] = $date_format . " - " . $today;
  895.             if ($today == $date_format) {
  897.                 $listCTSByAffectation = $entityManager->getRepository(UtilisateurInformation::class)->findBy(
  898.                     ['idAffectation' => $affectation->getIdAffectation()]
  899.                 );
  901.                 foreach ($listCTSByAffectation as $CTSByAffectation) {
  902.                     $entityManager->getRepository(CongeDroitAnnuel::class)->resetByAffectation(
  903.                         $CTSByAffectation->getIdAffectation(),
  904.                         $year,
  905.                         [1, 2, 3, 4]
  906.                     );
  907.                 }
  908.             }
  909.         }
  911.         return new JsonResponse(
  912.             $this->serialize([$array]),
  913.             JsonResponse::HTTP_OK,
  914.             [],
  915.             true
  916.         );
  917.     }
  920.     /**
  921.      * 
  922.      * @return JsonResponse
  923.      */
  924.     public function majDaysOff2Action()
  925.     {
  927.         $entityManager = $this->doctrine->getManager();
  928.         $listAffectations = $entityManager->getRepository(RefAffectation::class)->findAll();
  929.         $array = [];
  930.         foreach ($listAffectations as $affectation) {
  932.             $today = new \DateTime('now');
  933.             $year = $today->format('Y');
  934.             $today = $today->format('Y-m-d');
  935.             if (null != $affectation->getDateBascule()) {
  936.                 $date_format = $affectation->getDateBascule()->format('Y-m-d');
  937.             } else {
  938.                 $date_format = $affectation->getDateBascule();
  939.             }
  941.             $array[] = $date_format . " - " . $today;
  942.             if ($today == $date_format) {
  944.                 $array[] = "Coucou";
  946.                 $listCTSByAffectation = $entityManager->getRepository(UtilisateurInformation::class)->findBy(
  947.                     ['idAffectation' => $affectation->getIdAffectation()]
  948.                 );
  950.                 foreach ($listCTSByAffectation as $CTSByAffectation) {
  951.                     $entityManager->getRepository(CongeDroitAnnuel::class)->resetByAffectation2(
  952.                         $CTSByAffectation->getIdAffectation(),
  953.                         $year,
  954.                         [1, 2, 3, 4]
  955.                     );
  956.                 }
  957.             }
  958.         }
  960.         return new JsonResponse(
  961.             $this->serialize([$array]),
  962.             JsonResponse::HTTP_OK,
  963.             [],
  964.             true
  965.         );
  966.     }
  974.     /**
  975.      * @param string $validatonGroup
  976.      * @return \Symfony\Component\Form\FormInterface
  977.      */
  978.     private function handleRequest(
  979.         Request $request,
  980.         CongeDroitAnnuel $congeDroitAnnuel,
  981.         string $label
  982.     ) {
  983.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  984.         $request->request->replace(is_array($data) ? $data : []);
  986.         $form = $this->createForm(
  987.             CongeDroitAnnuelType::class,
  988.             $congeDroitAnnuel,
  989.             [
  990.                 'label' => $label
  991.             ]
  992.         );
  994.         $form->handleRequest($request);
  996.         return $form;
  997.     }
  999.     /**
  1000.      * @param array $states
  1001.      * @return mixed
  1002.      */
  1003.     private function serialize($item)
  1004.     {
  1005.         $data = ["items" => $item];
  1007.         $context = new SerializationContext();
  1008.         $context->setSerializeNull(true);
  1010.         return $this->serializer->serialize($data, 'json', $context);
  1011.     }
  1013.     private function setTotal(
  1014.         Utilisateur $utilisateur,
  1015.         CongeType $congeType,
  1016.         int $year,
  1017.         $date_conge_actuel,
  1018.         bool $calendrierScolaire
  1020.     ) {
  1022.         $byUserAndTypeAndStatus = $this->doctrine
  1023.             ->getRepository(Conge::class)
  1024.             ->findDayOffByTypeAndSatatusAndUser(
  1025.                 $utilisateur,
  1026.                 $congeType,
  1027.                 [Workflow::CO_ACCEPTED, Workflow::CO_SIGN],
  1028.                 $date_conge_actuel,
  1029.                 $year,
  1030.                 $calendrierScolaire
  1031.             );
  1032.         $congeAnnuelByType = $this
  1033.             ->doctrine
  1034.             ->getRepository(CongeDroitAnnuel::class)
  1035.             ->findOneBy([
  1036.                 'utilisateur' => $utilisateur,
  1037.                 'annee' => $year,
  1038.                 'congeType' => $congeType
  1039.             ]);
  1041.         if ($congeType->getCode() == 'RTT') {
  1042.             $nbJourTotal = ($congeAnnuelByType)
  1043.                 ? (float) $congeAnnuelByType->getNbJourTotal()
  1044.                 : 0;
  1046.             $total = $nbJourTotal - $byUserAndTypeAndStatus;
  1048.             $congeType->setNbJourTotal($nbJourTotal);
  1049.             $congeType->setSolde($total);
  1050.         } else {
  1051.             if ($calendrierScolaire) {
  1052.                 $byUserAndTypeAndStatusLastYear = $this->doctrine
  1053.                     ->getRepository(Conge::class)
  1054.                     ->findDayOffByTypeAndSatatusAndUser(
  1055.                         $utilisateur,
  1056.                         $congeType,
  1057.                         [Workflow::CO_ACCEPTED, Workflow::CO_SIGN],
  1058.                         $date_conge_actuel,
  1059.                         $year,
  1060.                         $calendrierScolaire
  1061.                     );
  1062.             } else {
  1063.                 $byUserAndTypeAndStatusLastYear = 0;
  1064.             }
  1066.             $congeAnnuelByTypeLastYear = $this
  1067.                 ->doctrine
  1068.                 ->getRepository(CongeDroitAnnuel::class)
  1069.                 ->findOneBy([
  1070.                     'utilisateur' => $utilisateur,
  1071.                     'annee' => $year - 1,
  1072.                     'congeType' => $congeType
  1073.                 ]);
  1076.             $ReportcongeAnnuel = $this
  1077.                 ->doctrine
  1078.                 ->getRepository(CongeDroitAnnuel::class)
  1079.                 ->findOneBy([
  1080.                     'utilisateur' => $utilisateur,
  1081.                     'annee' => $year + 1,
  1082.                     'congeType' => 4
  1083.                 ]);
  1084.             $nbJourReportY = ($ReportcongeAnnuel)
  1085.                 ? (float) $ReportcongeAnnuel->getNbJourTotal()
  1086.                 : 0;
  1088.             $nbJourTotalY = ($congeAnnuelByType)
  1089.                 ? (float) $congeAnnuelByType->getNbJourTotal()
  1090.                 : 0;
  1091.             $nbJourTotalLastY = ($congeAnnuelByTypeLastYear)
  1092.                 ? (float) $congeAnnuelByTypeLastYear->getNbJourTotal()
  1093.                 : 0;
  1094.             $nbJourTotalFracY = ($congeAnnuelByType)
  1095.                 ? (float) $congeAnnuelByType->getNbJourFractionnement()
  1096.                 : 0;
  1097.             $nbJourTotalLastYFrac = ($congeAnnuelByTypeLastYear)
  1098.                 ? (float) $congeAnnuelByTypeLastYear->getNbJourFractionnement()
  1099.                 : 0;
  1102.             $nbJourTotal = $nbJourTotalY + $nbJourTotalFracY + $nbJourReportY;
  1104.             $total = ($calendrierScolaire) ? $nbJourTotal - $byUserAndTypeAndStatus : $nbJourTotal - $byUserAndTypeAndStatus - $byUserAndTypeAndStatusLastYear;
  1108.             $congeType->setNbJourTotal($nbJourTotal);
  1109.             $congeType->setSolde($total);
  1110.         }
  1111.         return $congeType;
  1112.     }
  1115.     /**
  1116.      * @return array
  1117.      */
  1118.     private function manage(array $recapitulatif)
  1119.     {
  1120.         $soldeAfterLastYear = null;
  1121.         $soldeAfterCan = null;
  1122.         $soldeAfterCet = null;
  1123.         $soldeAfterRtt = null;
  1124.         $soldeAfterRaa = null;
  1125.         $soldeAfterFractionnement = null;
  1126.         $soldeBeforeRtt = $recapitulatif['totalRtt'] - $recapitulatif['givenRtt'];
  1127.         $soldeBeforeCet = $recapitulatif['totalCet'] - $recapitulatif['givenCet'];
  1128.         $soldeBeforeCan = $recapitulatif['totalCan'] - $recapitulatif['givenCa'];
  1129.         $soldeBeforeRaa = $recapitulatif['totalReport']- $recapitulatif['givenRaa'];
  1130.         //   $soldeLastYear = $recapitulatif['totalReport'];
  1131.         $soldeLastYear = 0;
  1133.         $total =
  1134.             // $soldeLastYear +
  1135.             $recapitulatif['totalCan'] +
  1136.             $recapitulatif['totalFrac'];
  1138.         $totalBefore =
  1139.             // $soldeLastYear +
  1140.             $soldeBeforeCan +
  1141.             $recapitulatif['totalFrac'];
  1143.         if (CongeType::CAN === $recapitulatif['code']) {
  1144.             $soldeAfterRtt = $soldeBeforeRtt;
  1145.             $soldeAfterCet = $soldeBeforeCet;
  1146.             $soldeAfterRaa = $soldeBeforeRaa;
  1148.             if ($soldeLastYear <= 0 && $recapitulatif['totalFrac'] <= 0) {
  1149.                 $soldeAfterLastYear = $soldeLastYear;
  1150.                 $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1151.                 $soldeAfterCan = $soldeBeforeCan - $recapitulatif['nbJour'];
  1152.             } else if ($soldeLastYear >= $recapitulatif['nbJour']) {
  1153.                 $soldeAfterLastYear = $soldeLastYear - $recapitulatif['nbJour'];
  1154.                 $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1155.                 $soldeAfterCan = $soldeBeforeCan;
  1156.             } else if ($soldeLastYear < $recapitulatif['nbJour']) {
  1157.                 $soldeAfterLastYear = 0;
  1158.                 $leave = $recapitulatif['nbJour'] - $soldeLastYear;
  1160.                 if ($recapitulatif['totalFrac'] >= $leave) {
  1161.                     $soldeAfterFractionnement = $recapitulatif['totalFrac'] - $leave;
  1162.                     $soldeAfterCan = $soldeBeforeCan;
  1163.                 } else {
  1164.                     $soldeAfterFractionnement = 0;
  1165.                     $soldeAfterCan = $soldeBeforeCan - ($leave - $recapitulatif['totalFrac']);
  1166.                 }
  1167.             }
  1168.         } elseif (CongeType::RTT === $recapitulatif['code']) {
  1169.             $soldeAfterLastYear = $soldeLastYear;
  1170.             $soldeAfterRtt = $soldeBeforeRtt - $recapitulatif['nbJour'];
  1171.             $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1172.             $soldeAfterCan = $soldeBeforeCan;
  1173.             $soldeAfterCet = $soldeBeforeCet;
  1174.             $soldeAfterRaa = $soldeBeforeRaa;
  1175.         } elseif (CongeType::CET === $recapitulatif['code']) {
  1176.             $soldeAfterLastYear = $soldeLastYear;
  1177.             $soldeAfterCet = $soldeBeforeCet - $recapitulatif['nbJour'];
  1178.             $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1179.             $soldeAfterCan = $soldeBeforeCan;
  1180.             $soldeAfterRtt = $soldeBeforeRtt;
  1181.             $soldeAfterRaa = $soldeBeforeRaa;
  1182.             
  1183.         } elseif (CongeType::RAA === $recapitulatif['code']) {
  1184.             $soldeAfterLastYear = $soldeLastYear;
  1185.             $soldeAfterRaa = $soldeBeforeRaa - $recapitulatif['nbJour'];
  1186.             $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1187.             $soldeAfterCan = $soldeBeforeCan;
  1188.             $soldeAfterRtt = $soldeBeforeRtt;
  1189.             $soldeAfterCet = $soldeBeforeCet;
  1190.         } else {
  1191.             $soldeAfterLastYear = $soldeLastYear;
  1192.             $soldeAfterRtt = $soldeBeforeRtt;
  1193.             $soldeAfterFractionnement = $recapitulatif['totalFrac'];
  1194.             $soldeAfterCan = $soldeBeforeCan;
  1195.             $soldeAfterRaa = $soldeBeforeRaa;
  1196.             $soldeAfterCet = $soldeBeforeCet;
  1197.         }
  1199.         // $totalAfter = /*$soldeAfterRtt +*/ $soldeAfterLastYear + $soldeAfterCan + $soldeAfterFractionnement;
  1200.         $totalAfter = /*$soldeAfterRtt + $soldeAfterLastYear + */ $soldeAfterCan + $soldeAfterFractionnement - $recapitulatif['givenRAANextYear'];
  1203.         return
  1204.             [
  1205.                 [
  1206.                     'libelle' => 'RTT',
  1207.                     'annuel' => (float) $recapitulatif['totalRtt'],
  1208.                     'before' => $soldeBeforeRtt,
  1209.                     'after' => $soldeAfterRtt
  1210.                 ],
  1212.                 [
  1213.                     'libelle' => 'CET',
  1214.                     'annuel' => (float) $recapitulatif['totalCet'],
  1215.                     'before' => $soldeBeforeCet,
  1216.                     'after' => $soldeAfterCet,
  1217.                 ],
  1218.                 [
  1219.                     'libelle' => 'Report année antérieure',
  1220.                     'annuel' => (float) $recapitulatif['totalReport'],
  1221.                     'before' => $soldeBeforeRaa,
  1222.                     //'after' => $soldeBeforeRaa,
  1223.                     'after' => $soldeAfterRaa
  1224.                 ],
  1225.                 [
  1226.                     'libelle' => 'Année en cours',
  1227.                     'annuel' => (float) $recapitulatif['totalCan'],
  1228.                     'before' => null,
  1229.                     'after' => null
  1230.                 ],
  1231.                 [
  1232.                     'libelle' => 'Jours de fractionnement*',
  1233.                     'annuel' => (float) $recapitulatif['totalFrac'],
  1234.                     'before' => null,
  1235.                     'after' => null
  1236.                 ],
  1237.                 [
  1238.                     'libelle' => 'Total congés annuels',
  1239.                     'annuel' => (float) $total,
  1240.                     'before' => (float) $totalBefore,
  1241.                     'after' => (float) $totalAfter
  1242.                 ],
  1243.                 isset($recapitulatif['calendrier_scolaire']) ? ["calendrier_scolaire" => $recapitulatif['calendrier_scolaire']] : []
  1244.             ];
  1245.     }
  1247.     /**
  1248.      * @return object
  1249.      */
  1250.     private function getServiceAccessRule()
  1251.     {
  1252.         return $this->accessRule;
  1253.     }
  1254. }