src/Controller/ExportCongeController.php line 275

Open in your IDE?
  1. <?php
  4. namespace App\Controller;
  6. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  7. use Symfony\Component\HttpFoundation\JsonResponse;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  10. use Symfony\Component\Routing\Annotation\Route;
  11. use App\Entity\RefRole;
  12. use App\Entity\Utilisateur;
  13. use App\Entity\UtilisateurInformation;
  14. use App\Entity\Workflow;
  15. use App\Entity\RefAffectation;
  16. use Doctrine\ORM\EntityManager;
  17. use JMS\Serializer\SerializationContext;
  18. use Doctrine\Persistence\ManagerRegistry;
  19. use App\Services\ExportConge;
  20. use App\Services\ExportCongeByUser;
  21. use JMS\Serializer\SerializerInterface;
  22. use App\Entity\RefAffectationCalendrier;
  24. /**
  25.  * Class ExportCongeController
  26.  * @package App\Controller
  27.  */
  28. class ExportCongeController extends AbstractController
  29. {
  30.     final public const BEGIN_YEAR = 2019;
  31.     private $doctrine;
  32.     private $exportConge;
  33.     private $exportCongeByUser;
  34.     private $serializer;
  35.     public function __construct(ManagerRegistry $doctrine, ExportConge $exportConge, ExportCongeByUser $exportCongeByUser, SerializerInterface $serializer)
  36.     {
  37.         $this->doctrine = $doctrine;
  38.         $this->exportConge = $exportConge;
  39.         $this->exportCongeByUser = $exportCongeByUser;
  40.         $this->serializer = $serializer;
  41.     }
  42.     /**
  43.      * @param $year
  44.      * @return JsonResponse
  45.      * @throws \Exception
  46.      */
  47.     #[Route(path: '/api/export/conges/{year}', name: 'ctsweb_export-conges', methods: ['GET'], requirements: ['year' => '\d+'])]
  48.     public function list($year)
  49.     {
  51.         $role = $this->getUser()->getUtilisateur()->getIdRole();
  53.         if (!in_array($role, Utilisateur::MANAGE)) {
  54.             return new JsonResponse([], JsonResponse::HTTP_FORBIDDEN);
  55.         }
  57.         $affectation = $this->getUser()->getIdAffectation();
  58.         $federation = $this->getUser()->getIdFederation();
  60.         if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role) {
  61.             $affectation = null;
  62.         } else if (RefRole::ROLE_DR === $role || RefRole::ROLE_DR_SIGNATAIRE === $role) {
  63.             $federation = null;
  64.         } else {
  65.             $affectation = null;
  66.             $federation = null;
  67.         }
  69.         /** @var EntityManager $entityManager */
  70.         $entityManager = $this->doctrine;
  72.         $data = $entityManager
  73.             ->getRepository(UtilisateurInformation::class)
  74.             ->getMyCtsDayOffInformation($federation, $affectation, $year);
  76.         $fileName = "synthese_" . (new \DateTime())->format("Y-m-d_H_i_s");
  78.         $response = $this->exportConge->exportList(
  79.             $data,
  80.             $year,
  81.             $affectation,
  82.             $federation,
  83.             false
  84.         );
  86.         $handle = fopen('php://memory', 'r+');
  87.         rewind($handle);
  89.         $dispositionHeader = $response->headers->makeDisposition(
  90.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  91.             "$fileName.xls"
  92.         );
  94.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  95.         $response->headers->set('Pragma', 'public');
  96.         $response->headers->set('Cache-Control', 'maxage=1');
  97.         $response->headers->set('Content-Disposition', $dispositionHeader);
  99.         return $response;
  100.     }
  102.     #[Route(path: '/api/export/conges/{idAff}/{year}/{calendrier}/{archive}', name: 'ctsweb_conges-annuel-annees-affectation-export', methods: ['GET'], requirements: ['id' => '\d+'])]
  103.     public function listAffectation(
  104.         $year,
  105.         $calendrier,
  106.         $archive
  107.     ) {
  109.         $affectation = $this->getUser()->getIdAffectation();
  111.         $role = $this->getUser()->getUtilisateur()->getIdRole();
  113.         if (!in_array($role, Utilisateur::MANAGE)) {
  114.             return new JsonResponse([], JsonResponse::HTTP_FORBIDDEN);
  115.         }
  117.         $federation = $this->getUser()->getIdFederation();
  119.         if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role) {
  120.             $affectation = null;
  121.         } else if (RefRole::ROLE_DR === $role || RefRole::ROLE_DR_SIGNATAIRE === $role) {
  122.             $federation = null;
  123.         } else {
  124.             $affectation = null;
  125.             $federation = null;
  126.         }
  128.         /** @var EntityManager $entityManager */
  129.         $entityManager = $this->doctrine;
  131.         $data = $entityManager
  132.             ->getRepository(UtilisateurInformation::class)
  133.             ->getMyCtsDayOffInformation($federation, $affectation, $year, $archive, $calendrier);
  135.         $fileName = "synthese_" . (new \DateTime())->format("Y-m-d_H_i_s");
  137.         $response = $this->exportConge->exportList(
  138.             $data,
  139.             $year,
  140.             $affectation,
  141.             $federation,
  142.             $calendrier
  143.         );
  145.         $handle = fopen('php://memory', 'r+');
  146.         rewind($handle);
  148.         $dispositionHeader = $response->headers->makeDisposition(
  149.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  150.             "$fileName.xls"
  151.         );
  153.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  154.         $response->headers->set('Pragma', 'public');
  155.         $response->headers->set('Cache-Control', 'maxage=1');
  156.         $response->headers->set('Content-Disposition', $dispositionHeader);
  158.         return $response;
  159.     }
  160.     /**
  161.      * @param Request $request
  162.      * @param Utilisateur $user
  163.      * @return mixed
  164.      * @throws \Exception
  165.      */
  166.     #[Route(path: '/api/export/conges/user/{id}/{year}', name: 'ctsweb_conges-export-year', methods: ['GET'], requirements: ['id' => '\d+', 'year' => '\d+'])]
  167.     public function listByUserConges(
  168.         int $id,
  169.         int $year,
  170.         // string $calendrier = "c",
  171.         int $archive = 0
  172.     ) {
  174.         $archive = boolval($archive);
  175.         $workflow = 'accepted';
  177.         $entityManager = $this->doctrine->getManager();
  179.         $user = $entityManager
  180.             ->getRepository(Utilisateur::class)
  181.             ->findOneBy(["idUtilisateur" => $id]);
  183.         $utilisateurInformation = $entityManager
  184.             ->getRepository(UtilisateurInformation::class)
  185.             ->findOneBy(["idUtilisateur" => $id]);
  188.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  189.         $affectation = $entityManager
  190.             ->getRepository(RefAffectation::class)
  191.             ->findOneBy(["idAffectation" => $Idaffectation]);
  194.         if ($workflow && (in_array($workflow, ['waiting', 'accepted', 'signed']))) {
  196.             if ($workflow == 'accepted') {
  197.                 $workflow = [Workflow::STATES[$workflow], Workflow::CO_SIGN];
  198.             } else {
  199.                 $workflow = [Workflow::STATES[$workflow]];
  200.             }
  201.         } else {
  202.             $workflow = [Workflow::CO_ACCEPTED, Workflow::CO_REJECT, Workflow::CO_SIGN];
  203.         }
  205.         $fileName = "Synthese__" . (new \DateTime())->format("Y-m-d_H_i_s");
  207.         $today = (new \DateTime());
  208.         $year = $today->format("Y");
  209.         $refcalendrier =  $entityManager
  210.             ->getRepository(RefAffectationCalendrier::class)
  211.             ->findAllByRefAffectation($Idaffectation);
  212.         $tableaubascule = $entityManager
  213.             ->getRepository(RefAffectationCalendrier::class)
  214.             ->getClosestDates($refcalendrier);
  215.         if (isset($tableaubascule[0]) &&  !empty($tableaubascule[0])) {
  216.             $calendrierScolaire = $tableaubascule[0]['calendrier_scolaire'];
  217.             $dateBasculeCongeSolaire = $tableaubascule[0]['date_bascule'];
  218.         } else {
  219.             $calendrierScolaire = false;
  220.             $dateBasculeCongeSolaire = null;
  221.         }
  222.         $today = new \DateTime();
  223.         if ($dateBasculeCongeSolaire) {
  224.             $yearBascule = $this->anneeMax($dateBasculeCongeSolaire);
  225.             if ($today >= $dateBasculeCongeSolaire) {
  226.                 $congeScolaire = $calendrierScolaire;
  227.             } else {
  228.                 $congeScolaire = !$calendrierScolaire;
  229.             }
  230.         } else {
  231.             $congeScolaire = $calendrierScolaire;
  232.             $yearBascule = null;
  233.         }
  234.         // $dateBasculeCongeSolaire = $affectation->getDateBascule();
  236.         $calendrier = ($congeScolaire) ? 's' : 'c';
  237.         if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
  238.             $year = $year - 1;
  239.         } else {
  240.             $year = $year;
  241.         }
  242.         $response = $this->exportCongeByUser
  243.             ->exportList(
  244.                 $user,
  245.                 $workflow,
  246.                 $year,
  247.                 $calendrier,
  248.                 $archive
  249.             );
  252.         $handle = fopen('php://memory', 'r+');
  253.         rewind($handle);
  255.         $dispositionHeader = $response->headers->makeDisposition(
  256.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  257.             "$fileName.xls"
  258.         );
  260.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  261.         $response->headers->set('Pragma', 'public');
  262.         $response->headers->set('Cache-Control', 'maxage=1');
  263.         $response->headers->set('Content-Disposition', $dispositionHeader);
  265.         return $response;
  266.     }
  268.     /**
  269.      * @param Request $request
  270.      * @param Utilisateur $user
  271.      * @return mixed
  272.      * @throws \Exception
  273.      */
  274.     #[Route(path: '/api/conges-droits-annees-export/{id}/{year}/{calendrier}/{archive}', name: 'ctsweb_conges-annuel-annees-export', methods: ['GET'], requirements: ['id' => '\d+', 'year' => '\d+'])]
  275.     public function listByUser(
  276.         int $id,
  277.         int $year,
  278.         string $calendrier = "c",
  279.         int $archive = 0
  280.     ) {
  282.         $archive = boolval($archive);
  283.         $workflow = 'accepted';
  285.         $entityManager = $this->doctrine->getManager();
  287.         $user = $entityManager
  288.             ->getRepository(Utilisateur::class)
  289.             ->findOneBy(["idUtilisateur" => $id]);
  291.         $utilisateurInformation = $entityManager
  292.             ->getRepository(UtilisateurInformation::class)
  293.             ->findOneBy(["idUtilisateur" => $id]);
  296.         $Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
  297.         $affectation = $entityManager
  298.             ->getRepository(RefAffectation::class)
  299.             ->findOneBy(["idAffectation" => $Idaffectation]);
  302.         if ($workflow && (in_array($workflow, ['waiting', 'accepted', 'signed']))) {
  304.             if ($workflow == 'accepted') {
  305.                 $workflow = [Workflow::STATES[$workflow], Workflow::CO_SIGN];
  306.             } else {
  307.                 $workflow = [Workflow::STATES[$workflow]];
  308.             }
  309.         } else {
  310.             $workflow = [Workflow::CO_ACCEPTED, Workflow::CO_REJECT, Workflow::CO_SIGN];
  311.         }
  313.         $fileName = "Synthese__" . (new \DateTime())->format("Y-m-d_H_i_s");
  315.         $response = $this->exportCongeByUser
  316.             ->exportList(
  317.                 $user,
  318.                 $workflow,
  319.                 $year,
  320.                 $calendrier,
  321.                 $archive
  322.             );
  325.         $handle = fopen('php://memory', 'r+');
  326.         rewind($handle);
  328.         $dispositionHeader = $response->headers->makeDisposition(
  329.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  330.             "$fileName.xls"
  331.         );
  333.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  334.         $response->headers->set('Pragma', 'public');
  335.         $response->headers->set('Cache-Control', 'maxage=1');
  336.         $response->headers->set('Content-Disposition', $dispositionHeader);
  338.         return $response;
  339.     }
  341.     /**
  342.      * @return JsonResponse
  343.      * @throws \Exception
  344.      */
  345.     #[Route(path: '/api/export/years', name: 'ctsweb_export-conges-list-year', methods: ['GET'])]
  346.     public function listYear()
  347.     {
  348.         $year = [];
  349.         $todayYear = (new \DateTime())->format("Y");
  350.         $begin = self::BEGIN_YEAR;
  352.         for ($begin; $begin <= $todayYear; $begin++) {
  353.             $year[] = ['year' => $begin];
  354.         }
  356.         return new JsonResponse(
  357.             $this->serialize($year),
  358.             JsonResponse::HTTP_OK,
  359.             [],
  360.             true
  361.         );
  362.     }
  364.     /**
  365.      * @param array $states
  366.      * @return mixed
  367.      */
  368.     private function serialize($item)
  369.     {
  370.         $data = ["items" => $item];
  372.         $context = new SerializationContext();
  373.         $context->setSerializeNull(true);
  375.         return $this->serializer->serialize($data, 'json', $context);
  376.     }
  377.     public  function anneeMax($dates)
  378.     {
  379.         $maxYear = null;
  381.         foreach ((array) $dates as $date) {
  382.             $year = intval(substr($date, 0, 4));
  383.             if ($maxYear === null || $year > $maxYear) {
  384.                 $maxYear = $year;
  385.             }
  386.         }
  388.         return $maxYear;
  389.     }
  390. }