src/Controller/FormationSessionController.php line 1130

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  6. use Doctrine\Persistence\ManagerRegistry;
  7. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\HttpFoundation\Response;
  10. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  11. use Symfony\Component\HttpFoundation\JsonResponse;
  12. use Symfony\Component\Routing\Annotation\Route;
  13. use App\Entity\FormationSession;
  14. use App\Entity\FormationSessionMotivation;
  15. use App\Entity\FormationMotivationType;
  16. use App\Entity\FormationSessionDocument;
  17. use App\Entity\FormationType;
  18. use App\Entity\ParametrageTexte;
  19. use App\Entity\Utilisateur;
  20. use App\Entity\UtilisateurInformation;
  21. use App\Entity\Workflow;
  22. use App\Entity\RefRole;
  23. use App\Entity\RefGabarit;
  24. use App\Form\FormationSessionType;
  25. use App\Form\FormationTypeType;
  26. use App\Form\FormationSessionDocumentType;
  27. use App\Form\FormationSessionMotivationType;
  28. use App\Services\AccessRule;
  29. use App\Services\ExportFormation;
  30. use App\Services\Mailer;
  31. use App\Services\GeneratePdf;
  32. use Symfony\Component\Mailer\MailerInterface;
  33. use Symfony\Component\Mime\Email;
  34. use Twig\Environment;
  35. use App\Services\Lib\EmailSHDecision;
  36. use App\Entity\RFederation;
  38. class FormationSessionController 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';
  44.     private ManagerRegistry $doctrine;
  45.     private AccessRule $accessRule;
  46.     private ExportFormation $exportFormation;
  47.     private MailerInterface $mailer;
  48.     private GeneratePdf $generatePdf;
  49.     private $twig;
  50.     private  $emailSHDecision;
  52.     public function __construct(ManagerRegistry $doctrine, AccessRule $accessRule, ExportFormation $exportFormation, MailerInterface $mailer, Environment $twig, GeneratePdf $generatePdf, EmailSHDecision $emailSHDecision)
  53.     {
  54.         $this->doctrine = $doctrine;
  55.         $this->accessRule = $accessRule;
  56.         $this->exportFormation = $exportFormation;
  57.         $this->mailer = $mailer;
  58.         $this->generatePdf = $generatePdf;
  59.         $this->twig = $twig;
  60.         $this->emailSHDecision = $emailSHDecision;
  61.     }
  63.     private function arrayOfElement($fs)
  64.     {
  65.         $data = [];
  67.         if (isset($fs) && !empty($fs)) {
  68.             $data = [
  69.                 'id' => isset($fs['id_formation_session']) ? $fs['id_formation_session'] : "",
  70.                 'id_utilisateur' => isset($fs['id_utilisateur']) ? $fs['id_utilisateur'] : "",
  71.                 'civilite' => isset($fs['civilite']) ? $fs['civilite'] : "",
  72.                 'nom' => isset($fs['nom']) ? $fs['nom'] : "",
  73.                 'prenom' => isset($fs['prenom']) ? $fs['prenom'] : "",
  74.                 'affectation_id' => isset($fs['affectation_id']) ? $fs['affectation_id'] : "",
  75.                 'libelle_affectation' => isset($fs['libelle_affectation']) ? $fs['libelle_affectation'] : "",
  76.                 'id_federation' => isset($fs['id_federation']) ? $fs['id_federation'] : "",
  77.                 'r_ser_libl' => isset($fs['r_ser_libl']) ? $fs['r_ser_libl'] : "",
  78.                 'libelle_poste' => isset($fs['libelle_poste']) ? $fs['libelle_poste'] : "",
  79.                 'titre' => isset($fs['titre']) ? $fs['titre'] : "",
  80.                 'libelle_organisme' => isset($fs['libelle_organisme']) ? $fs['libelle_organisme'] : "",
  81.                 'titre_session' => isset($fs['titre_session']) ? $fs['titre_session'] : "",
  82.                 'type_formation' => isset($fs['libelle_formation']) ? $fs['libelle_formation'] : "",
  83.                 'id_formation_type' => isset($fs['id_formation_type']) ? $fs['id_formation_type'] : "",
  84.                 'id_workflow' => isset($fs['id_workflow']) ? $fs['id_workflow'] : "",
  85.                 'libelle_action' => isset($fs['libelle_action']) ? $fs['libelle_action'] : "",
  86.                 'date_debut' => isset($fs['date_debut']) ? $fs['date_debut'] : "",
  87.                 'date_fin' => isset($fs['date_fin']) ? $fs['date_fin'] : "",
  88.                 'nb_jours' => isset($fs['nb_jours']) ? $fs['nb_jours'] : "",
  89.                 'avis_dtn' => isset($fs['avis_dtn']) ? $fs['avis_dtn'] : "",
  90.                 'avis_sh' => isset($fs['avis_sh']) ? $fs['avis_sh'] : "",
  91.                 'lieu_formation' => isset($fs['lieu_formation']) ? $fs['lieu_formation'] : "",
  92.                 'responsable' => [
  93.                     'nom_responsable' => isset($fs['nom_responsable']) ? $fs['nom_responsable'] : "",
  94.                     'mail_responsable' => isset($fs['mail_responsable']) ? $fs['mail_responsable'] : "",
  95.                     'telephone_responsable' => isset($fs['telephone_responsable']) ? $fs['telephone_responsable'] : "",
  96.                 ],
  97.                 'presentation' => isset($fs['presentation']) ? $fs['presentation'] : "",
  98.                 'lien' => isset($fs['lien']) ? $fs['lien'] : "",
  99.                 'certification' => isset($fs['certification']) ? $fs['certification'] : null,
  100.                 'commentaire_dtn' => isset($fs['commentaire_dtn']) ? $fs['commentaire_dtn'] : "",
  101.                 'commentaire_sh' => isset($fs['commentaire_sh']) ? $fs['commentaire_sh'] : "",
  102.                 'date_avis_dtn' => isset($fs['date_avis_dtn']) ? $fs['date_avis_dtn'] : "",
  103.                 'date_sgn_sh' => isset($fs['date_sgn_sh']) ? $fs['date_sgn_sh'] : "",
  105.             ];
  106.         }
  108.         return $data;
  109.     }
  111.     private function fillSessions($sessions, $sessions_motivations, $number_of_motivation_types)
  112.     {
  113.         $toFill = [];
  114.         $accents = ['é' => 'e'];
  115.         if (isset($sessions) && !empty($sessions)) {
  116.             for ($i = 0; $i < (is_countable($sessions) ? count($sessions) : 0); $i++) {
  117.                 $motivations_array = [];
  118.                 if (!empty($sessions_motivations) && isset($sessions_motivations[$i])) {
  119.                     for (
  120.                         $j = $i * $number_of_motivation_types;
  121.                         $j < $i * $number_of_motivation_types + $number_of_motivation_types && $j < count($sessions_motivations);
  122.                         $j++
  123.                     ) {
  124.                         $motivation = $sessions_motivations[$j];
  125.                         $libelle_motivation = strtr(
  126.                             strtolower(str_replace(' ', '_', (string) $motivation['libelle_motivation'])),
  127.                             $accents
  128.                         );
  129.                         $motivations_array[$libelle_motivation] = $motivation['valeur'];
  130.                     }
  131.                 }
  132.                 $session = $this->arrayOfElement($sessions[$i]);
  133.                 $session['motivation'] = $motivations_array;
  134.                 $toFill[] = $session;
  135.             }
  136.         }
  137.         return $toFill;
  138.     }
  140.     /**
  141.      * @return JsonResponse
  142.      */
  143.     #[Route(path: '/api/modifier-formation-types/{id}', name: 'ctsweb_modifier_formation_types')]
  144.     public function modifierFormationTypes(Request $request, FormationType $formationtype)
  145.     {
  148.         $form = $this->handleRequestType($request, $formationtype, 'all', 'post');
  150.         if ($form->isSubmitted() && $form->isValid()) {
  152.             $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  153.             $libelle = $data['libelle'];
  154.             $code = $data['code'];
  155.             if (empty($data['libelle'])) {
  156.                 $result = ['success' => false, 'info' => 'Le champ libellé est obligatoire.'];
  157.                 $status = JsonResponse::HTTP_OK;
  158.             } elseif (empty($data['code'])) {
  159.                 $result = ['success' => false, 'info' => 'Le champ code est obligatoire.'];
  160.                 $status = JsonResponse::HTTP_OK;
  161.             } else {
  162.                 $formationtype->setLibelleFormation($libelle);
  163.                 $formationtype->setCode($code);
  165.                 $entityManager = $this->doctrine->getManager();
  167.                 $entityManager->persist($formationtype);
  168.                 $entityManager->flush();
  171.                 $result = ['success' => true];
  172.                 $status = JsonResponse::HTTP_OK;
  173.             }
  174.         } else {
  175.             $result = [
  176.                 'success' => false,
  177.                 'data' => self::ERROR_VALIDATION_FORM,
  178.                 'error' => (string) $form->getErrors(true, false)
  179.             ];
  181.             $status = JsonResponse::HTTP_BAD_REQUEST;
  182.         }
  184.         return new JsonResponse($result, $status);
  185.     }
  187.     #[Route(path: '/api/supprimer_type_formation/{id}', name: 'ctsweb_formations_supprimer_type_formation')]
  188.     public function supprimerTypeFormation(Request $request, FormationType $formationType)
  189.     {
  190.         try {
  191.             // $form = $this->handleRequestType($request, $formationType, 'all', 'post');
  192.             $em = $this->doctrine->getManager();
  193.             $repository = $em->getRepository(FormationType::class);
  195.             $cg = $repository->countFormationTypeId($formationType->getIdFormationType());
  197.             if (count($cg) > 0) {
  198.                 $data = ['success' => false, 'data' => 'Ce type de formation est déjà utilisé. Il ne peut être supprimé'];
  199.                 return new JsonResponse($data);
  200.             } else {
  201.                 $repository->deleteFormationType($formationType->getIdFormationType());
  202.                 $data = ['success' => true, 'data' => 'Le Type a été supprimé'];
  203.                 return new JsonResponse($data);
  204.             }
  205.         } catch (\Exception $e) {
  206.             $data = ['success' => false, 'data' => $e->getMessage()];
  207.             return new JsonResponse($data);
  208.         }
  209.     }
  210.     /* Assertions for the function that get the formations:
  211.        - Let n = the number of formation types 
  212.        For each formation session, there are n formation types
  213.        - Results not involving motivations are sorted by id_formation_session DESC
  214.        - Results involving motivations are sorted by id_formation_motivation ASC
  215.        These assertions are fairly easy to preserve, but breaking any of these assertion will break
  216.        the algorithm. It was written this way to prevent doing a query to the database when
  217.        getting motivations for each formation session since they are in another table.
  218.        */
  219.     #[Route(path: '/api/create-FormationType/', name: 'ctsweb_formations_creer_types_formation')]
  220.     public function createFormationType(Request $request)
  221.     {
  223.         $formationtype = new FormationType();
  224.         $form = $this->handleRequestType($request, $formationtype, 'all', 'post');
  226.         try {
  227.             if ($form->isSubmitted() && $form->isValid()) {
  228.                 $entityManager = $this->doctrine->getManager();
  229.                 $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  230.                 $libelle = $data['libelle'] ?? null;
  231.                 $code = $data['code'] ?? null;
  232.                 if (!$libelle) {
  233.                     return new JsonResponse(
  234.                         ['success' => false, 'info' => 'Le champ libellé est obligatoire.'],
  235.                         JsonResponse::HTTP_OK
  236.                     );
  237.                 }
  238.                 if (!$code) {
  239.                     return new JsonResponse(
  240.                         ['success' => false, 'info' => 'Le champ code est obligatoire.'],
  241.                         JsonResponse::HTTP_OK
  242.                     );
  243.                 }
  244.                 $formationtype->setLibelleFormation($libelle);
  245.                 $formationtype->setCode($code);
  247.                 $entityManager->persist($formationtype);
  249.                 $entityManager->flush();
  251.                 return new JsonResponse(
  252.                     [
  253.                         'success' => true,
  254.                         'Formation' => $formationtype->getIdFormationType()
  255.                     ],
  256.                     JsonResponse::HTTP_CREATED
  257.                 );
  258.             } else {
  259.                 $result = [
  260.                     'success' => false,
  261.                     'data' => self::ERROR_VALIDATION_FORM,
  262.                     'error' => (string) $form->getErrors(true, false)
  263.                 ];
  264.             }
  265.         } catch (\Exception $e) {
  266.             // echo $e->getMessage();
  267.             $result = [
  268.                 'success' => false,
  269.                 'data' => self::ERROR_OCCURED
  270.             ];
  271.         }
  273.         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  274.     }
  276.     #[Route(path: '/api/get_liste_types_formation', name: 'ctsweb_formations_liste_types_formation')]
  277.     public function getListeTypesFormation()
  278.     {
  279.         $em = $this->doctrine->getManager();
  280.         $getListeTypesFormation = $em->getRepository(FormationType::class)
  281.             ->getSessionFormationType();
  283.         return new JsonResponse(['success' => true, 'data' => $getListeTypesFormation]);
  284.     }
  286.     #[Route(path: '/api/liste_formation_en_ecriture', name: 'ctsweb_mes_formations_en_attente')]
  287.     public function mesFormationsEnAttente()
  288.     {
  289.         $em = $this->doctrine->getManager();
  290.         $user = $this->getUser();
  291.         $number_of_motivation_types = 0;
  292.         $types = $em->getRepository(FormationMotivationType::class)->getNumberOfTypes();
  293.         if (!empty($types) && isset($types[0]['count'])) {
  294.             $number_of_motivation_types = $types[0]['count'];
  295.         }
  296.         $id_user = $user->getIdUtilisateur();
  297.         $pending_filter = $em->getRepository(FormationSession::class)
  298.             ->getPendingFilter();
  299.         $pending_sessions = $em->getRepository(FormationSession::class)
  300.             ->getSessionsOfUserWithWorkflow($id_user, $pending_filter);
  301.         $pending_sessions_motivations = $em->getRepository(FormationSession::class)
  302.             ->getMotivationsOfUserSessionsWithWorkflow($id_user, $pending_filter);
  303.         $pending = $this->fillSessions(
  304.             $pending_sessions,
  305.             $pending_sessions_motivations,
  306.             $number_of_motivation_types
  307.         );
  308.         return new JsonResponse(['success' => true, 'data' => $pending]);
  309.     }
  311.     #[Route(path: '/api/mes_formations_en_cours', name: 'ctsweb_mes_formations_en_cours')]
  312.     public function mesFormationsEnCours()
  313.     {
  314.         $em = $this->doctrine->getManager();
  315.         $user = $this->getUser();
  316.         $number_of_motivation_types = $em->getRepository(FormationMotivationType::class)
  317.             ->getNumberOfTypes()[0]['count'];
  318.         $id_user = $user->getIdUtilisateur();
  319.         $ongoing_filter = $em->getRepository(FormationSession::class)
  320.             ->getOngoingFilter();
  321.         $ongoing_sessions = $em->getRepository(FormationSession::class)
  322.             ->getSessionsOfUserWithWorkflow($id_user, $ongoing_filter);
  323.         $ongoing_sessions_motivations = $em->getRepository(FormationSession::class)
  324.             ->getMotivationsOfUserSessionsWithWorkflow($id_user, $ongoing_filter);
  325.         $ongoing = $this->fillSessions(
  326.             $ongoing_sessions,
  327.             $ongoing_sessions_motivations,
  328.             $number_of_motivation_types
  329.         );
  330.         return new JsonResponse(['success' => true, 'data' => $ongoing]);
  331.     }
  333.     #[Route(path: '/api/liste_formation_enAttente', name: 'ctsweb_formations_en_attente')]
  334.     public function formationsEnAttente()
  335.     {
  336.         $pending_sessions = null;
  337.         $pending_sessions_motivations = null;
  338.         $em = $this->doctrine->getManager();
  339.         $user = $this->getUser();
  340.         $number_of_motivation_types = $em->getRepository(FormationMotivationType::class)
  341.             ->getNumberOfTypes()[0]['count'];
  342.         $id_role = $user->getUtilisateur()->getIdRole();
  343.         $id_affectation = $user->getIdAffectation() == null ? 1 : $user->getIdAffectation()->getIdAffectation();
  344.         $id_federation = $user->getIdFederation() == null ? null : $user->getIdFederation()->getIdFederation();
  345.         $pending_filter = $em->getRepository(FormationSession::class)
  346.             ->getPendingFilter();
  347.         switch ($id_role) {
  348.             case RefRole::ROLE_FEDE:
  349.             case RefRole::ROLE_FEDE_INVITE:
  350.                 $pending_sessions =
  351.                     $em->getRepository(FormationSession::class)
  352.                     ->getSessionsOfFederationWithWorkflow($id_federation, $pending_filter);
  353.                 $pending_sessions_motivations =
  354.                     $em->getRepository(FormationSession::class)
  355.                     ->getMotivationsOfFederationSessionsWithWorkflow($id_federation, $pending_filter);
  356.                 break;
  357.             case RefRole::ROLE_DR:
  358.             case RefRole::ROLE_DR_SIGNATAIRE:
  359.                 $pending_sessions =
  360.                     $em->getRepository(FormationSession::class)
  361.                     ->getSessionsOfAffectationWithWorkflow($id_affectation, $pending_filter);
  362.                 $pending_sessions_motivations =
  363.                     $em->getRepository(FormationSession::class)
  364.                     ->getMotivationsOfAffectationSessionsWithWorkflow($id_affectation, $pending_filter);
  365.                 break;
  366.             case RefRole::ROLE_DS_ADMIN:
  367.             case RefRole::ROLE_DS_INVITE:
  368.             case RefRole::ROLE_DS_SIGNATAIRE:
  369.             case RefRole::ROLE_LECTEUR:
  370.                 $pending_sessions =
  371.                     $em->getRepository(FormationSession::class)
  372.                     ->getSessionsWithWorkflow($pending_filter);
  373.                 $pending_sessions_motivations =
  374.                     $em->getRepository(FormationSession::class)
  375.                     ->getMotivationsOfSessionsWithWorkflow($pending_filter);
  376.                 break;
  377.         }
  379.         $pending = $this->fillSessions(
  380.             $pending_sessions,
  381.             $pending_sessions_motivations,
  382.             $number_of_motivation_types
  383.         );
  384.         return new JsonResponse(['success' => true, 'data' => $pending]);
  385.     }
  387.     #[Route(path: '/api/liste_formation_enCours', name: 'ctsweb_formations_en_cours')]
  388.     public function formationsEnCours()
  389.     {
  390.         $ongoing_sessions = null;
  391.         $ongoing_sessions_motivations = null;
  392.         $em = $this->doctrine->getManager();
  393.         $user = $this->getUser();
  394.         $number_of_motivation_types = $em->getRepository(FormationMotivationType::class)
  395.             ->getNumberOfTypes()[0]['count'];
  396.         $id_role = $user->getUtilisateur()->getIdRole();
  397.         $id_affectation = $user->getIdAffectation() == null ? 1 : $user->getIdAffectation()->getIdAffectation();
  398.         $id_federation = $user->getIdFederation() == null ? null : $user->getIdFederation()->getIdFederation();
  399.         $ongoing_filter = $em->getRepository(FormationSession::class)
  400.             ->getOngoingFilter();
  402.         switch ($id_role) {
  403.             case RefRole::ROLE_FEDE:
  404.             case RefRole::ROLE_FEDE_INVITE:
  405.                 $ongoing_sessions =
  406.                     $em->getRepository(FormationSession::class)
  407.                     ->getSessionsOfFederationWithWorkflow($id_federation, $ongoing_filter);
  408.                 $ongoing_sessions_motivations =
  409.                     $em->getRepository(FormationSession::class)
  410.                     ->getMotivationsOfFederationSessionsWithWorkflow($id_federation, $ongoing_filter);
  411.                 break;
  412.             case RefRole::ROLE_DR:
  413.             case RefRole::ROLE_DR_SIGNATAIRE:
  414.                 $ongoing_sessions =
  415.                     $em->getRepository(FormationSession::class)
  416.                     ->getSessionsOfAffectationWithWorkflow($id_affectation, $ongoing_filter);
  417.                 $ongoing_sessions_motivations =
  418.                     $em->getRepository(FormationSession::class)
  419.                     ->getMotivationsOfAffectationSessionsWithWorkflow($id_affectation, $ongoing_filter);
  420.                 break;
  421.             case RefRole::ROLE_DS_ADMIN:
  422.             case RefRole::ROLE_DS_INVITE:
  423.             case RefRole::ROLE_DS_SIGNATAIRE:
  424.             case RefRole::ROLE_LECTEUR:
  425.                 $ongoing_sessions =
  426.                     $em->getRepository(FormationSession::class)
  427.                     ->getSessionsWithWorkflow($ongoing_filter);
  428.                 $ongoing_sessions_motivations =
  429.                     $em->getRepository(FormationSession::class)
  430.                     ->getMotivationsOfSessionsWithWorkflow($ongoing_filter);
  431.                 break;
  432.         }
  434.         $ongoing = $this->fillSessions(
  435.             $ongoing_sessions,
  436.             $ongoing_sessions_motivations,
  437.             $number_of_motivation_types
  438.         );
  439.         return new JsonResponse(['success' => true, 'data' => $ongoing]);
  440.     }
  443.     #[Route(path: '/api/formation/consulter/{id}', name: 'ctsweb_consulter_formation')]
  444.     public function consulter(FormationSession $sessionFormation)
  445.     {
  448.         $data = [];
  449.         $dataMotivation = [];
  450.         $idFormationSession = $sessionFormation->getIdFormationSession();
  451.         $em = $this->doctrine->getManager();
  453.         $listeDocuments = $em->getRepository(FormationSessionDocument::class)->getDocumentBySessionFormation($idFormationSession);
  454.         $motivations = $em->getRepository(FormationSessionMotivation::class)->getMotivationsBySessionFormation($idFormationSession);
  455.         $formations = $em->getRepository(FormationSession::class)->getSessionFormation($idFormationSession);
  456.         $workflow_filter = " fs.id_workflow =" . $formations[0]['id_workflow'];
  457.         $data['user'] = $em->getRepository(FormationSession::class)->getSessionsOfUserWithWorkflow($sessionFormation->getIdUtilisateur()->getIdUtilisateur(), $workflow_filter);
  458.         $data['user']['0']['telephonePortable'] = isset($data['user']['0']['telephoneportable']) ? $data['user']['0']['telephoneportable'] : "";
  459.         foreach ($motivations as $motivation) {
  460.             $dataMotivation[$motivation['id_formation_motivation']] = $motivation['valeur'];
  461.         }
  462.         try {
  464.             if ($sessionFormation instanceof FormationSession) {
  465.                 $data[] = [
  466.                     "id" => $sessionFormation->getIdFormationSession(),
  467.                     "id_utilisateur" => $sessionFormation->getIdUtilisateur()->getIdUtilisateur(),
  468.                     "organisme_formation" => $sessionFormation->getLibelleOrganisme(),
  469.                     "titre" => $sessionFormation->getTitre(),
  470.                     "titre_session" => $sessionFormation->getTitreSession(),
  471.                     "certification" => $sessionFormation->getCertification(),
  472.                     "libelle_formation" => $sessionFormation->getLibelleFormation(),
  473.                     "id_formation_type" => $formations[0]['id_formation_type'],
  474.                     "nb_jours" => $sessionFormation->getNbJours(),
  475.                     "avis_dtn" => $sessionFormation->getAvisDtn(),
  476.                     "avis_sh" => $sessionFormation->getAvisSh(),
  477.                     "presentation_formation" => $sessionFormation->getPresentation(),
  478.                     "id_workflow" => $formations[0]['id_workflow'],
  479.                     "date_debut" => $sessionFormation->getDateDebut(),
  480.                     "date_fin" => $sessionFormation->getDateFin(),
  481.                     "lien_formation" => $sessionFormation->getLienFormation(),
  482.                     "liste_documents" => (isset($listeDocuments[0]['liste_documents']) && !empty($listeDocuments[0]['liste_documents'])) ? json_decode((string) $listeDocuments[0]['liste_documents'], true, 512, JSON_THROW_ON_ERROR) : [],
  483.                     "lieuFormation" => $sessionFormation->getLieuFormation(),
  484.                     "responsable" => ["nom_prenom" => $sessionFormation->getPrenomResponsable() . " " . $sessionFormation->getNomResponsable(), "mail" => $sessionFormation->getMailResponsable(), "tel" => $sessionFormation->getTelephoneResponsable()],
  485.                     "motivation" => $this->tab_motivation($dataMotivation),
  486.                     'commentaire_dtn' => $sessionFormation->getCommentaireDtn(),
  487.                     'commentaire_sh' =>  $sessionFormation->getCommentaireSh(),
  488.                     'date_avis_dtn' =>  $sessionFormation->getDateAvisDtn(),
  489.                     'date_sgn_sh' =>  $sessionFormation->getDateSgnSh(),
  491.                 ];
  493.                 // -idFormationSession: 1
  494.                 // -idFormationType: FormationType {#2099 ▶}
  495.                 // -idUtilisateur: Utilisateur {#2098 ▶}
  496.                 // -idWorkflow: Workflow {#2127 ▶}
  497.                 // -titre: null
  498.                 // -dateDebut: DateTime @1661990400 {#2079 ▶}
  499.                 // -dateFin: DateTime @1662163200 {#2080 ▶}
  500.                 // -libelleOrganisme: "IPOS"
  501.                 // -lien: null
  502.                 // -nbJours: 3
  503.                 // -avisDtn: true
  504.                 // -avisSh: null
  505.                 // -lieuFormation: "Roubaix"
  506.                 // -nomResponsable: "Gilbert"
  507.                 // -prenomResponsable: "Coco"
  508.                 // -mailResponsable: "coco@gilbert.com"
  509.                 // -telephoneResponsable: "0612345678"
  511.                 // $data[] = array(
  512.                 //     "idEvenement" => $idEvenement,
  513.                 //     "idWorkflow" => $odm->getWorkflow()->getIdWorkflow(),
  514.                 //     "dateDebut" => $dateDebut,
  515.                 //     "dateFin" => $dateFin,
  516.                 //     "ville" => $ville,
  517.                 //     "pays" => $pays->getIdPays(),
  518.                 //     "paysLibelle" => $pays->getLibellePays(),
  519.                 //     "euro" => $pays->getUnionEuropeenne(),
  520.                 //     "motif" => $motif,
  521.                 //     "statut" => $statut,
  522.                 //     "espace_libre_DTN" => $odm->getespace_libre_DTN(),
  523.                 //     "espace_libre_HS" => $odm->getespace_libre_SH(),
  524.                 //     "avisdtn" => $avisdtn,
  525.                 //     "organisme" => $organisme,
  526.                 //     "avisDefaut" => $avisDefaut,
  527.                 //     "modifyOrDeleteEvent" => ($modifyOrDeleteEvent) ? $modifyOrDeleteEvent : false,
  528.                 //     "idUtilisateur" => $user->getIdUtilisateur(),
  529.                 //     "courrielUtilisateur" => $user->getCourriel(),
  530.                 //     "adresseUtilisateur" => $userInformation->getAdresse(),
  531.                 //     "prenomNomUtilisateur" => $prenomNomagent,
  532.                 //     "libellePoste"=> $userInformation->getIdPoste()->getLibellePoste()
  533.                 // );
  534.             }
  536.             $result = ['success' => true, 'data' => $data];
  537.         } catch (\Exception $e) {
  538.             $result = ['success' => false, 'data' => $e->getMessage()];
  539.         }
  540.         return new JsonResponse($result);
  541.     }
  543.     #[Route(path: '/api/formation/modifier/{id}', name: 'ctsweb_modifier_formation')]
  544.     public function modifierFormation(Request $request, FormationSession $formation)
  545.     {
  546.     // Utilisez la méthode 'json' pour renvoyer une réponse JSON avec les données que vous voulez déboguer
  547.     
  548.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  549.         $id_role = $this->getUser()->getUtilisateur()->getIdRole();
  550.         $em = $this->doctrine->getManager();
  551.         if (($id_role == RefRole::ROLE_DR || $id_role == RefRole::ROLE_DR_SIGNATAIRE)) {
  552.             if (!is_null($data['increment_workflow']) && $data['increment_workflow'] == true && $data['avis_sh'] == true) {
  553.                 $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_SIGNE);
  554.                 $formation->setAvisSh(true);
  555.                 $formation->setIdWorkflow($workflow);
  556.             } elseif ($data['avis_sh'] == false) {
  557.                 $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_REFUSE);
  558.                 $formation->setAvisSh(false);
  559.                 $formation->setIdWorkflow($workflow);
  560.             }
  561.             if (isset($data['commentaire_sh'])) {
  562.                 $formation->setCommentaireSh($data['commentaire_sh']);
  563.             }
  564.             if (isset($data['date_debut'])) {
  565.                 $newDateDebut = date_create_from_format("Y-m-d", $data['date_debut']);
  566.                 $formation->setDateDebut($newDateDebut);
  567.             }
  568.             if (isset($data['date_fin'])) {
  569.                 $newDateFin = date_create_from_format("Y-m-d", $data['date_fin']);
  570.                 $formation->setDateFin($newDateFin);
  571.             }
  572.             $formation->setDateSgnSh(new \DateTime());
  573.             // Appel function update document
  574.             $this->updateDocument($formation, $request);
  575.             $em->persist($formation);
  576.             $em->flush();
  577.             // Appel signature
  578.             $this->initSignatureFormations($formation->getIdFormationSession(), $workflow->getIdWorkflow());
  579.             $result = ['success' => true];
  580.             $status = JsonResponse::HTTP_OK;
  581.             return new JsonResponse($result, $status);
  582.         }
  583.         // AVISDTN
  584.         elseif (($id_role == RefRole::ROLE_FEDE || $id_role == RefRole::ROLE_FEDE_INVITE)) {
  585.             if (!is_null($data['avis_dtn']) && $data['avis_dtn'] == true) {
  586.                 $formation->setAvisDtn(true);
  587.             } else {
  588.                 $formation->setAvisDtn(false);
  589.             }
  590.             if (isset($data['commentaire_dtn'])) {
  591.                 $formation->setCommentaireDtn($data['commentaire_dtn']);
  592.             }
  593.             if (isset($data['date_debut'])) {
  594.                 $newDateDebut = date_create_from_format("Y-m-d", $data['date_debut']);
  595.                 $formation->setDateDebut($newDateDebut);
  596.             }
  597.             if (isset($data['date_fin'])) {
  598.                 $newDateFin = date_create_from_format("Y-m-d", $data['date_fin']);
  599.                 $formation->setDateFin($newDateFin);
  600.             }
  601.             $formation->setDateAvisDtn(new \DateTime());
  602.             $formation->setSignataireValidationfonctionelle($this->getUser()->getUtilisateur()->getIdUtilisateur());
  603.             // Appel function update document
  604.             $this->updateDocument($formation, $request);
  605.             if (($formation->getIdUtilisateur()->getRole()->getIdRole() == RefRole::ROLE_FEDE || $formation->getIdUtilisateur()->getRole()->getIdRole() == RefRole::ROLE_FEDE_INVITE) && (is_null($data['is_gerer_formation']) || $data['is_gerer_formation'] == false)) {
  606.                 $form = $this->handleRequest($request, $formation, 'all', 'post');
  607.                 $repository = $em->getRepository(FormationType::class);
  608.                 $formationType = $repository->findOneBy(['idFormationType' => (int) $formation->getIdFormationType()]);
  609.                 $formation->setIdFormationType($formationType);
  610.                 $idFormationSession = $em->getRepository(FormationSession::class)->findOneBy(['idFormationSession' => $formation->getIdFormationSession()]);
  611.                 $this->updateMotivation($data, $idFormationSession);
  612.             }
  614.             $em->persist($formation);
  615.             $em->flush();
  617.             $result = ['success' => true];
  618.             $status = JsonResponse::HTTP_OK;
  619.             return new JsonResponse($result, $status);
  620.         } elseif (($id_role == RefRole::ROLE_DS_ADMIN || $id_role == RefRole::ROLE_DS_SIGNATAIRE || $id_role == RefRole::ROLE_DS_INVITE)) {
  621.             if (!is_null($data['avis_dtn']) && $data['avis_dtn'] == true) {
  622.                 $formation->setAvisDtn(true);
  623.             } elseif ($data['avis_dtn'] == false && !is_null($data['avis_dtn'])) {
  624.                 $formation->setAvisDtn(false);
  625.             }
  626.             if (!is_null($data['increment_workflow']) && $data['increment_workflow'] == true) {
  627.                 if (!is_null($data['avis_sh']) && $data['avis_sh'] == true) {
  628.                     $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_SIGNE);
  629.                     $formation->setAvisSh(true);
  630.                     $formation->setIdWorkflow($workflow);
  631.                     // Appel signature
  632.                 } elseif ($data['avis_sh'] == false && !is_null($data['avis_sh'])) {
  633.                     $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_REFUSE);
  634.                     $formation->setAvisSh(false);
  635.                     $formation->setIdWorkflow($workflow);
  636.                 }
  637.                 $formation->setDateSgnSh(new \DateTime());
  638.                 // Appel function update document
  639.                 $this->updateDocument($formation, $request);
  640.                 $em->persist($formation);
  641.                 $em->flush();
  642.                 // Appel signature
  643.                 $this->initSignatureFormations($formation->getIdFormationSession(), $workflow->getIdWorkflow());
  644.                 $result = ['success' => true];
  645.                 $status = JsonResponse::HTTP_OK;
  646.                 return new JsonResponse($result, $status);
  647.             }
  648.             $em->persist($formation);
  649.             $em->flush();
  650.             $result = ['success' => true];
  651.             $status = JsonResponse::HTTP_OK;
  652.             return new JsonResponse($result, $status);
  653.         }
  655.         $form = $this->handleRequest($request, $formation, 'all', 'post');
  656.         $em = $this->doctrine->getManager();
  657.         $repository = $em->getRepository(FormationSession::class);
  659.         if ($form->isSubmitted() && $form->isValid()) {
  661.             $em = $this->doctrine->getManager();
  662.             if (($id_role == RefRole::ROLE_CTS)) {
  663.                 if (Workflow::FO_SIGNE == $formation->getIdWorkflow()->getIdWorkflow() || Workflow::FO_REFUSE == $formation->getIdWorkflow()->getIdWorkflow()) {
  664.                     $workflow = $em->getRepository(Workflow::class)->find($formation->getIdWorkflow()->getIdWorkflow());
  665.                     $formation->setIdWorkflow($workflow);
  666.                 } else {
  667.                     $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_EN_ATTENTE_DE_VALIDATION);
  668.                     $formation->setIdWorkflow($workflow);
  669.                 }
  670.             }
  672.             $entityManager = $this->doctrine->getManager();
  674.             if (!$repository->check_datedebutfin($formation)) {
  675.                 $result = [
  676.                     'success' => false,
  677.                     'error' => 'Date de fin de la formation doit être supérieure ou égale à la date début de formation '
  678.                 ];
  679.                 return new JsonResponse($result, JsonResponse::HTTP_OK);
  680.             }
  681.             $repository = $em->getRepository(FormationType::class);
  682.             $formationType = $repository->findOneBy(['idFormationType' => (int) $formation->getIdFormationType()]);
  683.             $formation->setIdFormationType($formationType);
  684.             $entityManager->persist($formation);
  685.             $entityManager->flush();
  687.             // Document
  688.             $document = new FormationSessionDocument();
  689.             $form = $this->handleRequestdocument($request, $document, 'all', 'post');
  690.             $idFormationSession = $em->getRepository(FormationSession::class)->findOneBy(['idFormationSession' => $formation->getIdFormationSession()]);
  691.             $document->setIdFormationSessionDocument($idFormationSession);
  692.             $listeDocuments = $em->getRepository(FormationSessionDocument::class)->getDocumentBySessionFormation($formation->getIdFormationSession());
  693.             if ($listeDocuments && (is_countable($listeDocuments) ? count($listeDocuments) : 0) > 0) {
  694.                 $document->setIdDocumentFormation($listeDocuments[0]['id_document_formation']);
  695.             }
  696.             $entityDocument = $this->doctrine->getManager();
  697.             $document->setLien($document->getLien());
  698.             $entityDocument->merge($document);
  700.             $entityDocument->flush();
  701.             $this->updateMotivation($data, $idFormationSession);
  702.             $result = ['success' => true];
  703.             $status = JsonResponse::HTTP_OK;
  704.         } else {
  705.             $result = [
  706.                 'success' => false,
  707.                 'data' => self::ERROR_VALIDATION_FORM,
  708.                 'error' => (string) $form->getErrors(true, false)
  709.             ];
  711.             $status = JsonResponse::HTTP_BAD_REQUEST;
  712.         }
  714.         return new JsonResponse($result, $status);
  715.     }
  716.     public function updateDocument($formation, $request)
  717.     {
  718.         $em = $this->doctrine->getManager();
  719.         $document = new FormationSessionDocument();
  720.         $form = $this->handleRequestdocument($request, $document, 'all', 'post');
  721.         $idFormationSession = $em->getRepository(FormationSession::class)->findOneBy(['idFormationSession' => $formation->getIdFormationSession()]);
  722.         $document->setIdFormationSessionDocument($idFormationSession);
  723.         $listeDocuments = $em->getRepository(FormationSessionDocument::class)->getDocumentBySessionFormation($formation->getIdFormationSession());
  724.         if ($listeDocuments && (is_countable($listeDocuments) ? count($listeDocuments) : 0) > 0) {
  725.             $document->setIdDocumentFormation($listeDocuments[0]['id_document_formation']);
  726.         }
  727.         $entityDocument = $this->doctrine->getManager();
  728.         $document->setLien($document->getLien());
  729.         $entityDocument->merge($document);
  731.         $entityDocument->flush();
  732.     }
  733.     public function updateMotivation($data, $idFormationSession)
  734.     {
  735.         $em = $this->doctrine->getManager();
  736.         // $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  737.         $datamotivation = $this->motivations($data);
  738.         foreach ($datamotivation as $motiv) {
  739.             $motivation = new FormationSessionMotivation();
  740.             $idformationmotivationType = $em->getRepository(FormationMotivationType::class)->findOneBy(['idFormationMotivation' => $motiv]);
  741.             $motivation->setIdFormationMotivation($idformationmotivationType);
  742.             $motivation->setIdFormationSession($idFormationSession);
  743.             $valeur = TRUE;
  744.             $motivation->setValeur($valeur);
  745.             $entitymotivation = $this->doctrine->getManager();
  746.             $entitymotivation->persist($motivation);
  748.             $entitymotivation->flush();
  749.         }
  750.     }
  751.     public function tab_motivation($motivations)
  752.     {
  753.         $motivation_array = ['1' => "formation_professionelle", '2' => "adaptation_immediate", '3' => "adaptation_previsible", '4' => "developement_qualification"];
  754.         foreach ($motivation_array as $v => $value) {
  755.             if (isset($motivations[$v])) {
  756.                 $data[$value] = true;
  757.             } else
  758.                 $data[$value] = false;
  759.         }
  761.         return $data;
  762.     }
  765.     #[Route(path: '/api/fs/{id}', name: 'api_fs_delete')]
  766.     public function delete(Request $request, FormationSession $formationSession)
  767.     {
  768.         $em = null;
  769.         $formation = null;
  770.         $entitymotivation = null;
  771.         try {
  772.             $form = $this->createDeleteForm($formationSession);
  773.             $form->handleRequest($request);
  774.             if ($form->isSubmitted() && $form->isValid()) {
  775.                 $accessRuleService = $this->accessRule;
  776.                 $accessRuleService->readerFirewall();
  778.                 $em = $this->doctrine->getManager();
  779.                 $em->remove($formationSession);
  780.                 $em->flush();
  781.             }
  784.             // Document
  785.             $document = new FormationSessionDocument();
  786.             $form = $this->handleRequestdocument($request, $document, 'all', 'post');
  787.             $idFormationSession = $em->getRepository(FormationSession::class)->findOneBy(['idFormationSession' => $formation->getIdFormationSession()]);
  788.             $entityDocument = $this->doctrine->getManager();
  789.             $entityDocument->remove($document);
  791.             $entityDocument->flush();
  793.             // MOTIVATION 
  794.             $motivation = new FormationSessionMotivation();
  795.             $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  796.             $datamotivation = $this->motivations($data);
  797.             foreach ($datamotivation as $motiv) {
  798.                 $idformationmotivationType = $em->getRepository(FormationMotivationType::class)->findOneBy(['idFormationMotivation' => $motiv]);
  799.                 $motivation->setIdFormationMotivation($idformationmotivationType);
  800.                 $motivation->setIdFormationSession($idFormationSession);
  801.                 $valeur = TRUE;
  802.                 $motivation->setValeur($valeur);
  803.                 $entitymotivation = $this->doctrine->getManager();
  804.                 $entitymotivation->remove($motivation);
  805.             }
  806.             $entitymotivation->flush();
  807.             $data = ['success' => true, 'data' => 'Delete Ok'];
  808.         } catch (\Exception $e) {
  809.             $data = ['success' => false, 'data' => $e->getMessage()];
  810.         }
  812.         return new JsonResponse($data);
  813.     }
  815.     /**
  816.      *
  817.      * @param FormationSession $fs The fs entity
  818.      *
  819.      * @return \Symfony\Component\Form\Form
  820.      */
  821.     private function createDeleteForm(FormationSession $formationSession)
  822.     {
  823.         return $this->createFormBuilder()
  824.             ->setAction($this->generateUrl('api_fs_delete', ['id' => $formationSession->getIdFormationSession()]))
  825.             ->setMethod(\Symfony\Component\HttpFoundation\Request::METHOD_DELETE)
  826.             ->getForm();
  827.     }
  832.     /**
  833.      * @return objectFormation
  834.      */
  835.     private function getServiceAccessRule()
  836.     {
  837.         return $this->accessRule;
  838.     }
  840.     #[Route(path: '/api/creation_formation', name: 'ctsweb_create_formations', methods: ['POST'])]
  841.     public function create(Request $request)
  842.     {
  843.         $utilisateurInformation = $this->getUser();
  844.         $utilisateur = $utilisateurInformation->getUtilisateur();
  845.         $idRole = $utilisateur->getIdRole();
  846.         $uid = $this->getUser()->getUtilisateur()->getIdUtilisateur();
  847.         $accessRuleService = $this->getServiceAccessRule();
  849.         if (!$accessRuleService->hasRightForTakingDayOff()) {
  850.             return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
  851.         }
  852.         $formation = new FormationSession();
  853.         $form = $this->handleRequest($request, $formation, 'all', 'post');
  854.         $em = $this->doctrine->getManager();
  855.         $repository = $em->getRepository(FormationSession::class);
  856.         try {
  857.             if ($form->isSubmitted() && $form->isValid()) {
  858.                 $entityManager = $this->doctrine->getManager();
  859.                 if (!$repository->check_datedebutfin($formation)) {
  860.                     $result = [
  861.                         'success' => false,
  862.                         'error' => 'Date de fin de la formation doit être supérieure ou égale à la date début de formation '
  863.                     ];
  864.                     return new JsonResponse($result, JsonResponse::HTTP_OK);
  865.                 }
  867.                 if (FormationSession::DTN === $request->request->get('from')) {
  868.                     $formation->setAvisDtn(true);
  869.                     $formation->setDateAvisDtn(new \DateTime());
  870.                 }
  873.                 $repository = $em->getRepository(FormationType::class);
  874.                 $formationType = $repository->findOneBy(['idFormationType' => (int) $formation->getIdFormationType()]);
  876.                 $formation->setIdFormationType($formationType);
  877.                 $repository = $em->getRepository(Workflow::class);
  878.                 if ($idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
  879.                     $formation->setAvisDtn(true);
  880.                     $formation->setDateAvisDtn(new \DateTime());
  881.                 }
  883.                 $workflow = $repository->findOneBy(['idWorkflow' => Workflow::FO_EN_ATTENTE_DE_VALIDATION]);
  884.                 $formation->setIdWorkflow($workflow); // ajout workflow
  886.                 $IdUtilisateur = $em->getRepository(Utilisateur::class)->findOneBy(['idUtilisateur' => $uid]);
  887.                 $formation->setIdUtilisateur($IdUtilisateur); //
  888.                 $formation->setLibelleFormation($formation->getTitre());
  889.                 $entityManager->persist($formation);
  891.                 $entityManager->flush();
  894.                 // Document
  895.                 $document = new FormationSessionDocument();
  896.                 $form = $this->handleRequestdocument($request, $document, 'all', 'post');
  897.                 $idFormationSession = $em->getRepository(FormationSession::class)->findOneBy(['idFormationSession' => $formation->getIdFormationSession()]);
  898.                 $document->setIdFormationSessionDocument($idFormationSession);
  899.                 $entityDocument = $this->doctrine->getManager();
  900.                 $entityDocument->persist($document);
  902.                 $entityDocument->flush();
  904.                 // MOTIVATION 
  905.                 $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  906.                 $datamotivation = $this->motivations($data);
  907.                 foreach ($datamotivation as $motiv) {
  908.                     $motivation = new FormationSessionMotivation();
  909.                     $idformationmotivationType = $em->getRepository(FormationMotivationType::class)->findOneBy(['idFormationMotivation' => $motiv]);
  910.                     $motivation->setIdFormationMotivation($idformationmotivationType);
  911.                     $motivation->setIdFormationSession($idFormationSession);
  912.                     $valeur = TRUE;
  913.                     $motivation->setValeur($valeur);
  914.                     $entitymotivation = $this->doctrine->getManager();
  915.                     $entitymotivation->persist($motivation);
  917.                     $entitymotivation->flush();
  918.                 }
  919.                 if ($idRole == RefRole::ROLE_CTS || $idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
  920.                     $this->sendMailNotification($formation);
  921.                 }
  922.                 return new JsonResponse(
  923.                     [
  924.                         'success' => true,
  925.                         'Formation' => $formation->getIdFormationSession()
  926.                     ],
  927.                     JsonResponse::HTTP_CREATED
  928.                 );
  929.             } else {
  930.                 $result = [
  931.                     'success' => false,
  932.                     'data' => self::ERROR_VALIDATION_FORM,
  933.                     'error' => (string) $form->getErrors(true, false)
  934.                 ];
  935.             }
  936.         } catch (\Exception $e) {
  937.             echo $e->getMessage();
  938.             $result = [
  939.                 'success' => false,
  940.                 'data' => self::ERROR_OCCURED
  941.             ];
  942.         }
  944.         return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
  945.     }
  946.     private function motivations($data)
  947.     {
  948.         $datamotivation = [];
  949.         $datamotivation['formation_professionelle'] = (isset($data['motivation']['formation_professionelle']) && (!$data['motivation']['formation_professionelle'])) ? false : 1;
  950.         $datamotivation['adaptation_immediate'] = (isset($data['motivation']['adaptation_immediate']) && (!$data['motivation']['adaptation_immediate'])) ? false : 2;
  951.         $datamotivation['adaptation_previsible'] = (isset($data['motivation']['adaptation_previsible']) && (!$data['motivation']['adaptation_previsible'])) ? false : 3;
  952.         $datamotivation['developement_qualification'] = (isset($data['motivation']['developement_qualification']) && (!$data['motivation']['developement_qualification'])) ? false : 4;
  953.         return array_filter($datamotivation);
  954.     }
  955.     private function sendMailNotification($formationObj)
  956.     {
  957.         $em = $this->doctrine->getManager();
  958.         $gabRep = $em->getRepository(RefGabarit::class);
  959.         $ui = $this->getUser();
  960.         $uid = $this->getUser()->getUtilisateur()->getIdUtilisateur();
  961.         $uimail = $em->getRepository(Utilisateur::class)->findBy(['idUtilisateur' => $uid])[0]->getCourriel();
  962.         $role = $this->getUser()->getUtilisateur()->getIdRole();
  964.         $subject = sprintf('CTS-WEB : Formation à valider - %s %s', $ui->getNom(), $ui->getPrenom());
  965.         $emailMailer = $this->getParameter('mailer_user');
  966.         $expediteurMail =  (filter_var($emailMailer, FILTER_VALIDATE_EMAIL)) ? $emailMailer : 'donotreply@sports.gouv.fr';
  967.         //$host = $this->getParameter('host');
  968.         $mail_contact = null;
  969.         $mail_ass_info = $this->doctrine->getManager()->getRepository(ParametrageTexte::class)->getByCode('COURRIEL_ASSISTANCE_INFO');
  970.         if ((is_countable($mail_ass_info) ? count($mail_ass_info) : 0) > 0)
  971.             $mail_contact = $mail_ass_info[0]->getTexte();
  973.         if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role || RefRole::ROLE_CTS === $role) {
  974.             $federation = $ui->getIdFederation()->getIdFederation();
  975.             $affectation = $ui->getIdAffectation()->getIdAffectation();
  976.         } else {
  977.             $federation = null;
  978.             $affectation = $ui->getIdAffectation()->getIdAffectation();
  979.         }
  981.         $recipients = $gabRep->emailNotification($federation, $affectation, 'emailFo');
  984.         // if (!filter_var($recipients, FILTER_VALIDATE_EMAIL)) {
  985.         //     $recipients = [];
  986.         // }
  987.         if (!empty($recipients)) {
  988.             $message = (new Email())
  989.                 ->subject($subject)
  990.                 ->from($expediteurMail)
  991.                 ->to(...$recipients)
  992.                 ->html(
  993.                     $this->twig->render(
  994.                         'Notification/notification_formation_dtn.html.twig',
  995.                         ['host' => $mail_contact, 'civility' => $ui->getCivilite(), 'lastname' => $ui->getNom(), 'firstname' => $ui->getPrenom(), 'mailDemandeur' => $expediteurMail]
  996.                     ),
  997.                     'text/html'
  998.                 );
  999.             $pdfData = $this->generatePdf->generatePdfFormation($formationObj, false, $affectation, false);
  1000.             $filename = sha1($formationObj->getIdFormationSession()) . '.pdf';
  1001.             $pdfFilePath = $this->getParameter('dir_file_formations') . $filename;
  1002.             file_put_contents($pdfFilePath, $pdfData);
  1003.             if (file_exists($pdfFilePath)) {
  1004.                 $pieceJointe = $pdfFilePath;
  1005.             } else {
  1006.                 $pieceJointe = false;
  1007.             }
  1008.             if ($pieceJointe) {
  1009.                 // Path to the PDF file to attach
  1010.                 if (file_exists($pdfFilePath)) {
  1011.                     // Create a attach for the attachment
  1012.                     chmod($pdfFilePath, 0644);
  1013.                     $message->attach(fopen($pdfFilePath, 'r'),  $filename);
  1014.                 }
  1015.             }
  1016.             $this->mailer->send($message);
  1017.             // Supprimer le fichier PDF temporaire après l'envoi de l'email (facultatif)
  1018.             unlink($pdfFilePath);
  1019.         }
  1020.     }
  1022.     /**
  1023.      * @param FormationSession $formation
  1024.      * @return \Symfony\Component\Form\FormInterface
  1025.      */
  1026.     private function handleRequestType(
  1027.         Request $request,
  1028.         FormationType $formationType,
  1029.         string $label,
  1030.         string $validationGroup
  1031.     ) {
  1032.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  1033.         $request->request->replace(is_array($data) ? $data : []);
  1034.         $form = $this->createForm(
  1035.             FormationTypeType::class,
  1036.             $formationType,
  1037.             ['label' => $label, 'validation_groups' => $validationGroup]
  1038.         );
  1039.         $form->handleRequest($request);
  1040.         return $form;
  1041.     }
  1043.     /**
  1044.      * @return \Symfony\Component\Form\FormInterface
  1045.      */
  1046.     private function handleRequest(
  1047.         Request $request,
  1048.         FormationSession $formation,
  1049.         string $label,
  1050.         string $validationGroup
  1051.     ) {
  1052.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  1053.         if ('status' != $label) {
  1054.             $data['nom_responsable'] = $data['responsable']['nom_responsable'];
  1055.             $data['mail_responsable'] = $data['responsable']['mail_responsable'];
  1056.             $data['telephone_responsable'] = $data['responsable']['telephone_responsable'];
  1057.         }
  1058.         $request->request->replace(is_array($data) ? $data : []);
  1059.         $form = $this->createForm(
  1060.             FormationSessionType::class,
  1061.             $formation,
  1062.             ['label' => $label, 'validation_groups' => $validationGroup]
  1063.         );
  1064.         $form->handleRequest($request);
  1065.         return $form;
  1066.     }
  1068.     /**
  1069.      * @return \Symfony\Component\Form\FormInterface
  1070.      */
  1071.     private function handleRequestdocument(
  1072.         Request $request,
  1073.         FormationSessionDocument $document,
  1074.         string $label,
  1075.         string $validationGroup
  1076.     ) {
  1077.         $datadocument = [];
  1078.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  1079.         $datadocument['lien'] = json_encode($data['liste_documents'], JSON_THROW_ON_ERROR);
  1080.         $request->request->replace(is_array($datadocument) ? $datadocument : []);
  1081.         $form = $this->createForm(
  1082.             FormationSessionDocumentType::class,
  1083.             $document,
  1084.             ['label' => $label, 'validation_groups' => $validationGroup]
  1085.         );
  1086.         $form->handleRequest($request);
  1087.         return $form;
  1088.     }
  1089.     /**
  1090.      * @return \Symfony\Component\Form\FormInterface
  1091.      */
  1092.     private function handleRequestmotivation(
  1093.         Request $request,
  1094.         FormationSessionMotivation $motivation,
  1095.         string $label,
  1096.         string $validationGroup
  1097.     ) {
  1098.         $datamotivation = [];
  1099.         $data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  1100.         $datamotivation['formation_professionelle'] = isset($data['motivation']['formation_professionelle']) ? 1 : false;
  1101.         $datamotivation['adaptation_immediate'] = isset($data['motivation']['adaptation_immediate']) ? 2 : false;
  1102.         $datamotivation['adaptation_previsible'] = isset($data['motivation']['adaptation_previsible']) ? 3 : false;
  1103.         $datamotivation['developement_qualification'] = isset($data['motivation']['developement_qualification']) ? 4 : false;
  1104.         $request->request->replace(is_array($datamotivation) ? $datamotivation : []);
  1105.         $form = $this->createForm(
  1106.             FormationSessionMotivationType::class,
  1107.             $motivation,
  1108.             ['label' => $label, 'validation_groups' => $validationGroup]
  1109.         );
  1110.         $form->handleRequest($request);
  1111.         return $form;
  1112.     }
  1113.     /**
  1114.      * Get a user from the Security Token Storage.
  1115.      *
  1116.      * @return UserInterface|object|null
  1117.      *
  1118.      * @throws \LogicException If SecurityBundle is not available
  1119.      *
  1120.      * @see TokenInterface::getUser()
  1121.      *
  1122.      * @final since version 3.4
  1123.      */
  1124.     protected function getUser()
  1125.     {
  1126.         if (!$this->has('security.token_storage')) {
  1127.             throw new \LogicException('The SecurityBundle is not registered in your application. Try running "composer require symfony/security-bundle".');
  1128.         }
  1130.         if (null === $token = $this->get('security.token_storage')->getToken()) {
  1131.             return null;
  1132.         }
  1134.         if (!\is_object($user = $token->getUser())) {
  1135.             // e.g. anonymous authentication
  1136.             return null;
  1137.         }
  1139.         return $user;
  1140.     }
  1142.     #[Route(path: '/api/delete_formation/{id}', name: 'ctsweb_delete_formations')]
  1143.     public function deleteFormations(Request $request, FormationSession $formationSession)
  1144.     {
  1145.         //$idFormationSession = $sessionFormation->getIdFormationSession();
  1146.         try {
  1147.             // $form = $this->handleRequest($request, $formationSession, 'all', 'post');
  1148.             $em = $this->doctrine->getManager();
  1149.             $repository = $em->getRepository(FormationSession::class);
  1150.             $cg = $repository->findOneBy(['idFormationSession' => $formationSession->getIdFormationSession()]);
  1151.             $role = $this->getUser()->getUtilisateur()->getIdRole();
  1153.             if ($cg) {
  1154.                 if ($cg->getIdWorkflow()->getIdWorkflow() == Workflow::FO_SIGNE) {
  1158.                     $workflow = $em->getRepository(Workflow::class)->find(Workflow::FO_ANNULATION);
  1159.                     $formationSession->setIdWorkflow($workflow);
  1160.                     $em->persist($formationSession);
  1161.                     $em->flush();
  1162.                     $data = ['success' => true, 'data' => 'La formation a été annulé'];
  1163.                     return new JsonResponse($data);
  1164.                 } else {
  1165.                     $filename = sha1($formationSession->getIdFormationSession());
  1166.                     $repository->deleteformation($formationSession->getIdFormationSession());
  1167.                     $repertoire = $this->getParameter('dir_file_formations');
  1168.                     $nomFichier = $filename . '.pdf';
  1169.                     $this->supprimerFichier($repertoire, $nomFichier);
  1170.                     $data = ['success' => true, 'data' => 'La formation a été supprimée'];
  1171.                     return new JsonResponse($data);
  1172.                 }
  1173.             }
  1174.         } catch (\Exception $e) {
  1175.             $data = ['success' => false, 'data' => $e->getMessage()];
  1176.             return new JsonResponse($data);
  1177.         }
  1178.     }
  1179.     public  function supprimerFichier($repertoire, $nomFichier)
  1180.     {
  1181.         $cheminFichier = $repertoire . $nomFichier;
  1183.         // Vérifiez si le fichier existe avant de le supprimer
  1184.         if (file_exists($cheminFichier)) {
  1185.             if (unlink($cheminFichier)) {
  1186.                 // return "Le fichier $nomFichier a été supprimé avec succès.";
  1187.             } else {
  1188.                 // return "Une erreur s'est produite lors de la suppression du fichier.";
  1189.             }
  1190.         } else {
  1191.             // return "Le fichier $nomFichier n'existe pas dans le répertoire.";
  1192.         }
  1193.     }
  1194.     /**
  1195.      * @return Response
  1196.      */
  1197.     #[Route(path: '/api/export_pdf_mes_Formations/{id}', name: 'ctsweb_export_pdf_mes_Formations')]
  1198.     public function exportpdfFormations(FormationSession $formation)
  1199.     {
  1201.         if (
  1202.             Workflow::FO_SIGNE === $formation->getIdWorkflow()->getIdWorkflow()
  1203.         ) {
  1204.             $filename = sha1($formation->getIdFormationSession()) . '.pdf';
  1205.             $path = $this->getParameter('dir_file_formations') . $filename;
  1207.             if (file_exists($path)) {
  1208.                 $content = file_get_contents($path, FILE_USE_INCLUDE_PATH);
  1210.                 $response = $this->getResponse($content, $filename);
  1211.             } else {
  1212.                 $response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
  1213.             }
  1214.         } else {
  1215.             $serviceGeneratePdf = $this->generatePdf;
  1217.             $content = $serviceGeneratePdf->generatePdfFormation($formation, false);
  1218.             $filename = sha1($formation->getIdFormationSession()) . '.pdf';
  1220.             $response = $this->getResponse($content, $filename);
  1221.         }
  1223.         return $response;
  1224.     }
  1225.     public function getResponse(string $content, string $filename): Response
  1226.     {
  1227.         return new Response(
  1228.             $content,
  1229.             Response::HTTP_OK,
  1230.             [
  1231.                 'Content-Type' => 'application/pdf',
  1232.                 'Content-Length' => strlen($content),
  1233.                 'Content-Disposition' => "attachment;filename=\"{$filename}",
  1234.                 'Accept-Ranges' => 'bytes'
  1235.             ]
  1236.         );
  1237.     }
  1239.     /**
  1240.      * @param Utilisateur $utilisateur
  1241.      * @return JsonResponse
  1242.      */
  1243.     #[Route(path: '/api/formations/archive/{idUser}', name: 'ctsweb_formations_archive', requirements: ['idUser' => '\d+'])]
  1244.     public function findMyArchive($idUser)
  1245.     {
  1246.         $idUtilisateur = ($idUser == 0) ? $this->getUser()->getIdUtilisateur() : $idUser;
  1247.         $repository = $this->doctrine->getManager()->getRepository(FormationSession::class);
  1249.         $accepted = Workflow::FO_SIGNE;
  1250.         $refused = Workflow::FO_REFUSE;
  1251.         $filter = " fs.id_workflow IN (" . $accepted . ", " . $refused . ")";
  1252.         //  les formations validées/refusées de plus d’un an sont visibles uniquement dans les synthèses et archives cf. 7.2.4 et 7.3.5) 
  1254.         //@todo:A verifier
  1255.         $formationListe = $repository->getSessiondocument($idUtilisateur, $filter);
  1256.         if (isset($formationListe[0]) && isset($formationListe[0]['liste_documents'])) {
  1257.             $formationListe[0]['liste_documents'] = json_decode((string) $formationListe[0]['liste_documents'], true, 512, JSON_THROW_ON_ERROR);
  1258.         }
  1259.         if (isset($formationListe[0]) && isset($formationListe[0]['id'])) {
  1260.             $formationListe[0]['id'] = $formationListe[0]['id'];
  1261.         }
  1263.         try {
  1264.             $data = ['success' => true, 'data' => $formationListe];
  1265.         } catch (\Exception $e) {
  1266.             $data = ['success' => false, 'error' => $e->getMessage()];
  1267.         }
  1269.         return new JsonResponse($data);
  1270.     }
  1273.     #[Route(path: '/api/export_formations_enCours', name: 'ctsweb_export_csv_formation_en_cours')]
  1274.     public function exportFormationsEnCour()
  1275.     {
  1276.         $em = $this->doctrine->getManager();
  1277.         $user = $this->getUser();
  1278.         $federation = $user->getIdFederation();
  1279.         $affectation = $user->getIdAffectation();
  1280.                 $listformationEnCours = $this->formationsEnCours();
  1281.         $data_retour = [];
  1282.         $data = (array) $listformationEnCours;
  1283.         $dataValues = array_values($data)[1];
  1284.         $dataArray = json_decode((string) $dataValues, true, 512, JSON_THROW_ON_ERROR);
  1285.         foreach ($dataArray["data"] as $key => $value) {
  1287.             $value['motivation'] = $em->getRepository(FormationSessionMotivation::class)->getMotivationsBySessionFormationtype($value['id']);
  1288.             $data_retour['data'][] = $value;
  1289.         }
  1291.         $response = $this->exportFormation->exportListEncoursAttente((array) $data_retour, $affectation, $federation, 'en cours');
  1292.         $handle = fopen('php://memory', 'r+');
  1293.         $fileName = 'Formations_En_Cours_' . date('d_m_Y');
  1294.         rewind($handle);
  1295.         $dispositionHeader = $response->headers->makeDisposition(
  1296.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  1297.             $fileName . '.xls'
  1298.         );
  1299.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  1300.         $response->headers->set('Pragma', 'public');
  1301.         $response->headers->set('Cache-Control', 'maxage=1');
  1302.         $response->headers->set('Content-Disposition', $dispositionHeader);
  1303.         return $response;
  1304.     }
  1306.     #[Route(path: '/api/export_formations_enAttente', name: 'ctsweb_export_csv_formation_en_attente')]
  1307.     public function exportFormationsEnAttente()
  1308.     {
  1309.         $em = $this->doctrine->getManager();
  1310.         $user = $this->getUser();
  1311.         $federation = $user->getIdFederation();
  1312.         $affectation = $user->getIdAffectation();
  1313.         $listformationEnAttente = $this->formationsEnAttente();
  1315.         $data_retour = [];
  1316.         $data = (array) $listformationEnAttente;
  1317.         $dataValues = array_values($data)[1];
  1318.         $dataArray = json_decode((string) $dataValues, true, 512, JSON_THROW_ON_ERROR);
  1319.         foreach ($dataArray["data"] as $key => $value) {
  1321.             $value['motivation'] = $em->getRepository(FormationSessionMotivation::class)->getMotivationsBySessionFormationtype($value['id']);
  1322.             $data_retour['data'][] = $value;
  1323.         }
  1324.         $response = $this->exportFormation->exportListEncoursAttente((array) $data_retour, $affectation, $federation, 'en attente');
  1325.         $handle = fopen('php://memory', 'r+');
  1326.         $fileName = 'Formations_En_Attente_'. date('d_m_Y');
  1327.         rewind($handle);
  1328.         $dispositionHeader = $response->headers->makeDisposition(
  1329.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  1330.             $fileName . '.xls'
  1331.         );
  1332.         $response->headers->set('Content-Type', 'text/vnd.ms-excel; charset=utf-8');
  1333.         $response->headers->set('Pragma', 'public');
  1334.         $response->headers->set('Cache-Control', 'maxage=1');
  1335.         $response->headers->set('Content-Disposition', $dispositionHeader);
  1336.         return $response;
  1337.     }
  1338.     function AffichageFormationArchivesAction($idUser)
  1339.     {
  1340.         $idUtilisateur = ($idUser == 0) ? $this->getUser()->getIdUtilisateur() : $idUser;
  1341.         $em = $this->doctrine->getManager();
  1342.         $repository = $em->getRepository(FormationSession::class);
  1343.         $workflow_filter = $em->getRepository(FormationSession::class)->getOngoingFilter();
  1344.         try {
  1345.             $Liste = $repository->getSessionsOfUserWithWorkflow($idUtilisateur, $workflow_filter);
  1346.             $data = ['success' => true, 'data' => $Liste];
  1347.         } catch (\Exception $e) {
  1348.             $data = ['success' => false, 'error' => $e->getMessage()];
  1349.         }
  1351.         return new JsonResponse($data);
  1352.     }
  1354.     public function initSignatureFormations($idformation, $idWorkflow)
  1355.     {
  1356.         try {
  1357.             $em = $this->doctrine->getManager();
  1358.             $FormationRepo = $em->getRepository(FormationSession::class);
  1359.             $utilisateurRepository = $em->getRepository(Utilisateur::class);
  1360.             $formationObj = $FormationRepo->find($idformation);
  1361.             $info_signature = $this->getInfosSignatureSh($formationObj);
  1362.             $signatureDtn = $this->getInfosSignatureDtn($formationObj);
  1363.             $signature_Dtn = (isset($signatureDtn) && !empty($signatureDtn)) ? $signatureDtn : false;
  1364.             $info_signature['signatureDtn'] = $signature_Dtn;
  1365.             $idUtilisateur = $formationObj->getIdUtilisateur()->getIdUtilisateur();
  1366.             $affectation = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idUtilisateur)->getIdAffectation()->getIdAffectation();
  1367.             $formationObj = $FormationRepo->find($idformation);
  1368.             $formationObj->setDateSgnSh(new \DateTime());
  1369.             $idUtilisateur = $formationObj->getIdUtilisateur()->getIdUtilisateur();
  1370.             $emails = $utilisateurRepository->findCourrielById($idUtilisateur);
  1371.             $email = isset($emails[0]['courriel']) ? $emails[0]['courriel'] : null;
  1373.             $em->persist($formationObj);
  1374.             $em->flush();
  1375.             $this->generatePdf->generatePdfFormation($formationObj, false, $affectation, $info_signature);
  1376.             $filename = sha1($formationObj->getIdFormationSession()) . '.pdf';
  1377.             $pdfFilePath = $this->getParameter('dir_file_formations') . $filename;
  1378.             if (file_exists($pdfFilePath)) {
  1379.                 $pieceJointe = $pdfFilePath;
  1380.             } else {
  1381.                 $pieceJointe = false;
  1382.             }
  1383.             if ($idWorkflow == Workflow::FO_SIGNE) {
  1384.                 $decision = EmailSHDecision::SIGNED;
  1385.             } else {
  1386.                 $decision = EmailSHDecision::REFUSED;
  1387.             }
  1389.             $beginDate = $formationObj->getDateDebut();
  1390.             $mail = $this->emailSHDecision->getMailFormation(
  1391.                 $decision,
  1392.                 EmailSHDecision::FO,
  1393.                 $email,
  1394.                 $beginDate,
  1395.                 $pieceJointe,
  1396.                 $filename
  1397.             );
  1398.             if ($mail) {
  1399.                 $this->mailer->send($mail);
  1400.             }
  1401.             $message = 'Tous les conges ont été signés avec succès.';
  1402.             $return = array(
  1403.                 'success' => true,
  1404.                 'data' => $message
  1405.             );
  1406.         } catch (\Exception $e) {
  1407.             $message = 'Un ou plusieurs congés n\'ont pu être signés.';
  1408.             $return = array(
  1409.                 'success' => false,
  1410.                 'data' => $e->getMessage()
  1411.             );
  1412.         }
  1413.         return new JsonResponse(
  1414.             $return,
  1415.             JsonResponse::HTTP_CREATED
  1416.         );
  1417.     }
  1420.     public function getInfosSignatureSh($formationObj)
  1421.     {
  1422.         $em = $this->doctrine->getManager();
  1423.         $idSignataire = $this->getUser()->getUtilisateur()->getIdUtilisateur();
  1424.         $affectationSignataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idSignataire)->getIdAffectation()->getIdAffectation();
  1426.         $idUtilisateur = $formationObj->getIdUtilisateur()->getIdUtilisateur();
  1427.         $affectation = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idUtilisateur)->getIdAffectation()->getIdAffectation();
  1428.         # TODO : Valider la logique de sélection du signataire en fonction de l'affectation.
  1429.        /* if ($affectationSignataire == $affectation) {
  1430.             $signataire = $em->getRepository(UtilisateurInformation::class)->findOneBy(['utilisateur' => $idSignataire]);
  1431.         } else {
  1432.             if ($affectation != 1) {
  1433.                 $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDrSuperieur($affectation);
  1434.             } else {
  1435.                 $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDsSuperieur($affectation);
  1436.             }
  1437.             $signataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($drsignataire);
  1438.         }
  1439.         $path = $signataire->getScan() ? $this->getParameter('dir_file_signature') . $signataire->getScan()->getAbsolutePath() : '';*/
  1440.         if ($affectation != 1) {
  1441.             $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDrSuperieur($affectation);
  1442.         } else {
  1443.             $drsignataire = $em->getRepository(UtilisateurInformation::class)->findDsSuperieur($affectation);
  1444.         }
  1445.         $signataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($drsignataire);
  1446.         
  1447.         $path = $signataire->getScan() ? $this->getParameter('dir_file_signature') . $signataire->getScan()->getAbsolutePath() : '';
  1449.         if ($path && file_exists($path)) {
  1450.             chmod($path, 0644);
  1451.             $content = file_get_contents($path);
  1452.             if ($content !== false) {
  1453.                 $pathvrai = $path;
  1454.             } else {
  1455.                 // Gérer l'erreur si le contenu n'a pas pu être lu
  1456.                 $pathvrai = "";
  1457.             }
  1458.         } else {
  1459.             // Gérer l'erreur si le fichier n'existe pas
  1460.             $pathvrai = "";
  1461.         }
  1462.         $info_signature = [
  1463.             'nom' => $signataire->getNom(),
  1464.             'prenom' => $signataire->getPrenom(),
  1465.             'dateSignature' => date("d/m/Y"),
  1466.             'sup' => true,
  1467.             'fonction' => $signataire->getFonction(),
  1468.             'path' => $pathvrai,
  1469.             'civilite' => $signataire->getCivilite(),
  1470.             'signatureDtn' => false
  1471.         ];
  1473.         return $info_signature;
  1474.     }
  1475.     public function getInfosSignatureDtn($formationObj)
  1476.     {
  1477.         $em = $this->doctrine->getManager();
  1478.         $idUtilisateur = $formationObj->getIdUtilisateur()->getIdUtilisateur();
  1479.         $signatureDtn = [];
  1480.         if (!is_null($formationObj->getSignataireValidationfonctionelle())) {
  1481.             $informationSignataireDTN = $em->getRepository(UtilisateurInformation::class)->findOneBy(['utilisateur' => $formationObj->getSignataireValidationfonctionelle()]);
  1482.             if ($informationSignataireDTN && !is_null($informationSignataireDTN->getIdPoste())) {
  1483.                 if ($informationSignataireDTN->getIdFederation()) {
  1484.                     $oFede = $em->getRepository(RFederation::class)->getRFederationByRefFederation($informationSignataireDTN->getIdFederation()->getIdFederation());
  1485.                     $libelleFedertation = $oFede->getRSerLibl();
  1486.                 }
  1487.                 $signatureDtn = [
  1488.                     'nom' => $informationSignataireDTN->getNom(),
  1489.                     'prenom' => $informationSignataireDTN->getPrenom(),
  1490.                     'fonction' => $informationSignataireDTN->getFonction(),
  1491.                     'path' => $informationSignataireDTN->getScan() ? $this->getParameter('dir_file_signature') . $informationSignataireDTN->getScan()->getAbsolutePath() : false,
  1492.                     'federation' => $libelleFedertation ?: '',
  1493.                     'civilite' => $informationSignataireDTN->getCivilite()
  1494.                 ];
  1495.             }
  1496.         } else {
  1497.             $idFederation = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idUtilisateur)->getIdFederation()->getIdFederation();
  1498.             $UserInfoDTN = $em->getRepository(UtilisateurInformation::class)->getUserInfoDTN($idFederation, 3);
  1500.             if (isset($UserInfoDTN[0]) && is_array($UserInfoDTN[0])) {
  1501.                 $libelleFedertation = $UserInfoDTN[0]['r_ser_libl'];
  1502.                 $idsignDtn = $UserInfoDTN[0]['id_utilisateur'];
  1503.                 $infSignataireDTN = $em->getRepository(UtilisateurInformation::class)->findOneBy(array('utilisateur' =>  $idsignDtn));
  1504.                 $path = $infSignataireDTN->getScan() ? $this->getParameter('dir_file_signature') . $infSignataireDTN->getScan()->getAbsolutePath() : '';
  1505.                 if ($path && file_exists($path)) {
  1506.                     chmod($path, 0644);
  1507.                     $content = file_get_contents($path);
  1508.                     if ($content !== false) {
  1509.                         $pathvrai = $path;
  1510.                     } else {
  1511.                         // Gérer l'erreur si le contenu n'a pas pu être lu
  1512.                         $pathvrai = "";
  1513.                     }
  1514.                 } else {
  1515.                     // Gérer l'erreur si le fichier n'existe pas
  1516.                     $pathvrai = "";
  1517.                 }
  1518.                 $signatureDtn = array(
  1519.                     'nom' => $infSignataireDTN->getNom(),
  1520.                     'prenom' => $infSignataireDTN->getPrenom(),
  1521.                     'fonction' => $infSignataireDTN->getFonction(),
  1522.                     'path' => $pathvrai,
  1523.                     'federation' => $libelleFedertation ? $libelleFedertation : '',
  1524.                     'civilite' => $infSignataireDTN->getCivilite()
  1525.                 );
  1526.             }
  1527.         }
  1528.         return (isset($signatureDtn) && !empty($signatureDtn)) ? $signatureDtn : false;
  1529.     }
  1531.     #[Route('/api/formation/update_state/{id}', name: 'cts_update_formation_state', methods: ['POST'])]
  1532.     /**
  1533.      * Cette méthode met à jour le statut d'une formation existante.
  1534.      * 
  1535.      * @param Request $request La requête contenant les données de la formation à mettre à jour.
  1536.      * @param int $id L'ID de la formation à mettre à jour.
  1537.      * @return JsonResponse Retourne un JSON contenant l'ID de la formation mis à jour ou un message d'erreur si la mise à jour échoue.
  1538.      */
  1539.     public function updateStateForm(Request $request, FormationSession $formation): JsonResponse
  1540.     {
  1541.         // Initialisation du gestionnaire d'entités
  1542.         $em = $this->doctrine->getManager();
  1544.         // Décodage des données reçues en JSON
  1545.         $formData = json_decode($request->getContent(), true);
  1547.         // Création et traitement du formulaire
  1548.         //TODO : à vérifier la soumission du formulaire
  1549.         #$form = $this->handleRequest($request, $formation, 'status', 'post');
  1551.         // Récupération du workflow associé à la formation
  1552.         $workflow = $em->getRepository(Workflow::class)->find($formData['idWorkflow']);
  1554.         try {
  1556.             $formation->setIdWorkflow($workflow);
  1557.             // Si le workflow est 'signé' ou 'refusé'
  1558.             if ((Workflow::FO_SIGNE  == $workflow->getIdWorkflow()) || (Workflow::FO_REFUSE == $workflow->getIdWorkflow())) {
  1559.                 // Appel de la méthode de signature
  1560.                 //TODO : à bien vérifier
  1561.                 $this->initSignatureFormations($formation->getIdFormationSession(), $workflow->getIdWorkflow());
  1563.                 // Mise à jour de la date de signature
  1564.                 $formation->setDateSgnSh(new \DateTime());
  1565.             }
  1566.             //mettre à jour l'avis du SH
  1567.             if (Workflow::FO_SIGNE == $workflow->getIdWorkflow()) {
  1568.                 $formation->setAvisSh(true);
  1569.             } elseif (Workflow::FO_REFUSE == $workflow->getIdWorkflow()) {
  1570.                 $formation->setAvisSh(false);
  1571.             }
  1574.             // Enregistrement des modifications dans la base de données
  1575.             $em->persist($formation);
  1576.             $em->flush();
  1578.             $data = [
  1579.                 'success' => true,
  1580.                 'message' => 'La formation a été mise à jour avec succès'
  1581.             ];
  1582.         } catch (\Exception $e) {
  1583.             // Gestion des erreurs inattendues
  1584.             $data = [
  1585.                 'status' => Response::HTTP_INTERNAL_SERVER_ERROR,
  1586.                 'message' => 'Une erreur est survenue lors de la mise à jour de la formation. Veuillez réessayer ultérieurement. ' . $e->getMessage()
  1587.             ];
  1588.         }
  1590.         return new JsonResponse($data);
  1591.     }
  1592.     function retirerAccents($str)
  1593.     {
  1594.         $str = str_replace(
  1595.             ['à', 'á', 'â', 'ã', 'ä', 'å', 'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î', 'ï', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö', 'ù', 'ú', 'û', 'ü', 'ý', 'ÿ'],
  1596.             ['a', 'a', 'a', 'a', 'a', 'a', 'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i', 'n', 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 'u', 'y', 'y'],
  1597.             $str
  1598.         );
  1599.         return strtolower(str_replace(" ", "", $str));
  1600.     }
  1601. }