src/Controller/bilanControllers/JobEvalKanbanController.php line 439

Open in your IDE?
  1. <?php
  3. namespace App\Controller\bilanControllers;
  5. use App\Entity\bilan\Criticite;
  6. use App\Entity\bilan\Frequence;
  7. use App\Entity\bilan\Gravite;
  8. use App\Entity\bilan\Job;
  9. use App\Entity\bilan\Mission;
  10. use App\Entity\bilan\MOG;
  11. use App\Entity\bilan\MOP;
  12. use App\Entity\bilan\Risque;
  13. use App\Entity\bilan\Situation;
  14. use App\Entity\bilan\SituationRisque;
  15. use App\Entity\bilan\Task;
  16. use App\Entity\Group;
  17. use App\Entity\Configuration\CompanyEntity;
  18. use App\Repository\bilan\JobRepository;
  19. use App\Repository\bilan\TaskRepository;
  20. use App\Service\SelectedEntityService;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\HttpFoundation\Response;
  25. use Symfony\Component\HttpFoundation\RequestStack;
  26. use Symfony\Component\Routing\Annotation\Route;
  27. use Symfony\Component\Security\Core\Security;
  28. use App\Entity\User;
  30. /**
  31.  * @Route("/eval/job")
  32.  */
  33. class JobEvalKanbanController extends AbstractController
  34. {
  35.     private $jobRepository;
  36.     private $security;
  37.     private $requestStack;
  38.     private $selectedEntityService;
  40.     public function __construct(JobRepository $jobRepository, Security $security, RequestStack $requestStack, SelectedEntityService $selectedEntityService)
  41.     {
  42.         $this->jobRepository = $jobRepository;
  43.         $this->security = $security;
  44.         $this->requestStack = $requestStack;
  45.         $this->selectedEntityService = $selectedEntityService;
  46.     }
  48.     /**
  49.      * @Route("/list",  name="evalJob_list", methods={"GET","POST"})
  50.      */
  51.     public function list(Request $request, TaskRepository $taskRepository):Response
  52.     {
  53.         if (!$request->isXmlHttpRequest()) {
  54.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  55.         }
  56.         
  57.         if ($request->request->has('missionId')) {
  58.             $entityManager = $this->getDoctrine()->getManager();
  59.             $missionId = $request->request->get('missionId');
  60.             $mission = $entityManager->getRepository(Mission::class)->findOneBy(['id'=>$missionId]);
  61.             
  62.             if (!$mission) {
  63.                 return new JsonResponse(array('status' => 'error', 'message' => 'Mission not found'), 404);
  64.             }
  65.             
  66.             $taskRepositoryData = $taskRepository->transformAllMision($mission);
  67.             return new JsonResponse($taskRepositoryData);
  68.         }
  69.         
  70.         return new JsonResponse(array('status' => 'error', 'message' => 'Missing missionId parameter'), 400);
  71.     }
  72.     /**
  73.     * @Route("/new", name="save_TS",methods={"POST"})
  74.     */
  75.     public function new(Request $request): Response
  76.     {
  77.         if (!$request->isXmlHttpRequest()) {
  78.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  79.         }
  80.         if (isset($request->request)) {
  81.             $user = $this->getUser();
  82.             $entityManager = $this->getDoctrine()->getManager();
  83.             
  84.             if (!$entityManager->isOpen()) {
  85.                 $entityManager->create(
  86.                     $entityManager->getConnection(),
  87.                     $entityManager->getConfiguration()
  88.                 );
  89.             }
  90.             $task_id='';
  91.             $situation_id='';
  92.             $entityId = $request->request->get('entity_id');
  93.             $situationTitle = $request->request->get('situation');
  94.             $risques= $request->request->get('risques');
  95.             $type_save= $request->request->get('type_save');
  96.             //
  97.             if ($type_save=='saveTS') {
  98.                 $missionId = $request->request->get('missionId');
  99.                 $taskTitle = $request->request->get('task');
  100.                 $mission = $entityManager->getRepository(Mission::class)->findOneBy(['id'=>$missionId]);
  101.                
  102.                 $task = new Task();
  103.                 $task->setMission($mission);
  104.                 $task->setTitle($taskTitle);
  105.                 $task->setSlug(Task::generateSlug($taskTitle));
  106.                 $task->setCreatedBy($user->getId());
  107.                 $task->setCreatedAt(new \DateTime('now'));
  108.                 $entityManager->persist($task);
  110.                 try {
  111.                     $entityManager->flush();
  112.                     $task_id=$task->getId();
  113.                     $dataT['task'] = [
  114.                     'idTask'=>$task->getId(),
  115.                     'titleTask'=>$task->getTitle(),
  116.                    /* 'date'=>$mission->getCreatedAt()->format('d/m/Y'),
  117.                     'job'=>$job_title,
  118.                     'mission'=>$mission_title,
  119.                     'processus'=>$processus_ref,
  120.                     'responsible'=>$responsible->getFullName()*/
  121.                 ];
  122.                     $data[] =$dataT;
  123.                 } catch (\Exception $e) {
  124.                     $data = array('status' => 'error', 'message' => $e->getMessage());
  125.                 }
  126.             } else {
  127.                 $task_id =  $request->request->get('idTask');
  128.                 $task = $entityManager->getRepository(Task::class)->findOneBy(['id'=>$task_id]);
  129.                 $dataT['task'] = [
  130.                     'idTask'=>$task->getId(),
  131.                     'titleTask'=>$task->getTitle(),
  132.                 ];
  133.                 $data[] =$dataT;
  134.             }
  135.                 
  136.             
  137.                
  138.             // dd( $mission);
  139.             $situation = new Situation();
  140.             $situation->setTask($task);
  141.             $situation->setTitle($situationTitle);
  142.             $situation->setCreatedBy($user->getId());
  143.             $situation->setCreatedAt(new \DateTime('now'));
  144.             $entityManager->persist($situation);
  146.             try {
  147.                 $entityManager->flush();
  148.                 $dataS['situation'] = [
  149.                     'idSituation'=>$situation->getId(),
  150.                     'titleSituation'=>$situation->getTitle(),
  151.                    /* 'date'=>$mission->getCreatedAt()->format('d/m/Y'),
  152.                     'job'=>$job_title,
  153.                     'mission'=>$mission_title,
  154.                     'processus'=>$processus_ref,
  155.                     'responsible'=>$responsible->getFullName()*/
  156.                 ];
  157.                 $data[] =$dataS;
  158.                 foreach ($risques as $id) {
  159.                     $risque = $entityManager->getRepository(Risque::class)->findOneBy(['id'=>$id]);
  160.                     $situation_risque = new SituationRisque();
  161.                     $situation_risque->setSituation($situation);
  162.                     $situation_risque->setRisque($risque);
  163.                     $companyEntity = null;
  165.                     if ($entityId) {
  166.                         $companyEntity = $entityManager
  167.                             ->getRepository(CompanyEntity::class)
  168.                             ->find($entityId);
  169.                     } else {
  170.                         $companyEntity = $this->selectedEntityService->getSelectedEntity();
  171.                     }
  172.                     $situation_risque->setCompanyEntity($companyEntity);
  173.                     $entityManager->persist($situation_risque);
  174.                     $entityManager->flush();
  175.                     $dataSR['situation_R'][] = [
  176.                     'idSR'=>$situation_risque->getId(),
  177.                     'titlerisque'=>$risque->getNom(),
  178.                     'idRisque'=>$risque->getId(),
  179.                     'idSituation'=>$situation->getId(),
  180.                    /* 'date'=>$mission->getCreatedAt()->format('d/m/Y'),
  181.                     'job'=>$job_title,
  182.                     'mission'=>$mission_title,
  183.                     'processus'=>$processus_ref,
  184.                     'responsible'=>$responsible->getFullName()*/
  185.                     ];
  186.                 }
  187.                 $data[] =$dataSR;
  188.             } catch (\Exception $e) {
  189.                 $data = array('status' => 'error', 'message' => $e->getMessage());
  190.             }
  191.         }
  192.         $response =$data;
  193.         return new JsonResponse($response, 200);
  194.     }
  195.     /**
  196.     * @Route("/situation/{id}/edit", name="edit_situation", methods={"GET","POST"})
  197.     */
  198.     public function editSituation(Request $request, Situation $situation): Response
  199.     {
  200.         if (!$request->isXmlHttpRequest()) {
  201.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  202.         }
  203.         if (isset($request->request)) {
  204.             $entityId = $request->request->get('entity_id');
  205.             $situationTitle = $request->request->get('situation');
  206.             $risques= $request->request->get('risques');
  207.             $risques_selected= $request->request->get('risques_selected');
  208.          
  209.             
  210.             // Récupération de l'utilisateur connecté
  211.             $user = $this->getUser();
  212.            
  213.             $risques_add = array_diff($risques, $risques_selected);
  214.            
  215.             $risques_deleted = array_diff($risques_selected, $risques);
  216.             $entityManager = $this->getDoctrine()->getManager();
  217.                
  218.             $situation->setTitle($situationTitle);
  219.               
  220.             try {
  221.                 $entityManager->flush();
  222.                 $dataS['situation'] = [
  223.                     'idSituation'=>$situation->getId(),
  224.                     'titleSituation'=>$situation->getTitle(),
  225.                  
  226.                     ];
  227.                 $data[] =$dataS;
  228.                 $situations_risques = $entityManager->getRepository(SituationRisque::class)->findBy(['situation'=>$situation->getId()]);
  229.                 foreach ($situations_risques as $situation_risque) {
  230.                     if (in_array($situation_risque->getRisque()->getId(), $risques_deleted)) {
  231.                         $entityManager->remove($situation_risque);
  232.                         $entityManager->flush();
  233.                     }
  234.                 }
  235.                 foreach ($risques_add as $id) {
  236.                     $risque = $entityManager->getRepository(Risque::class)->findOneBy(['id'=>$id]);
  237.                     $situation_risque = new SituationRisque();
  238.                     $situation_risque->setSituation($situation);
  239.                     $situation_risque->setRisque($risque);
  240.                     $entityManager->persist($situation_risque);
  241.                     $entityManager->flush();
  242.                 }
  243.                 // Déterminer l'entité à filtrer pour la réponse
  244.                 $selectedEntity = $this->selectedEntityService->getSelectedEntity();
  246.                 
  247.                 $situations_risques = $entityManager->getRepository(SituationRisque::class)->findBy(['situation'=>$situation->getId()]);
  248.                 $dataSR['situation_R'] = []; // Initialisation du tableau
  249.                 foreach ($situations_risques as $situation_risque) {
  250.                     // Filtrer par entité sélectionnée ou montrer tout si aucune entité sélectionnée
  251.                     if (
  252.                         !$selectedEntity ||
  253.                         !$situation_risque->getCompanyEntity() ||
  254.                         $situation_risque->getCompanyEntity()->getId() === $selectedEntity->getId()
  255.                     ) {
  256.                         $dataSR['situation_R'][] = [
  257.                         'idSR'=>$situation_risque->getId(),
  258.                         'titlerisque'=>$situation_risque->getRisque()->getNom(),
  259.                         'idRisque'=>$situation_risque->getRisque()->getId(),
  260.                         'idSituation'=>$situation->getId(),
  261.                         ];
  262.                     }
  263.                 }
  264.                 $data[] =$dataSR;
  265.             } catch (\Exception $e) {
  266.                 $data = array('status' => 'error', 'message' => $e->getMessage());
  267.             }
  268.         }
  269.          
  270.         $response =$data;
  271.         return new JsonResponse($response, 200);
  272.     }
  273.      /**
  274.     * @Route("/task/{id}/edit", name="editJob_task", methods={"POST"})
  275.     */
  276.     public function editTask(Request $request, Task $task): Response
  277.     {
  279.          if (!$request->isXmlHttpRequest()) {
  280.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  281.         }
  282.         if (isset($request->request)) {
  283.             $taskTitle = $request->request->get('valeur');
  284.             $entityManager = $this->getDoctrine()->getManager();
  285.             $task->setTitle($taskTitle);
  286.             try {
  287.                 $entityManager->flush();
  288.                 $data=['update'=>1,'title'=>$taskTitle];
  289.             } catch (\Exception $e) {
  290.                 $data = array('status' => 'error', 'message' => $e->getMessage());
  291.             }
  292.         }
  293.             $response =$data;
  294.             return new JsonResponse($response, 200);
  296.     }
  297.     /**
  298.      * @Route("/situation/{id}/get", name="situation_get", methods={"GET","POST"})
  299.      */
  300.     public function getSituation(Request $request, Situation $situation): Response
  301.     {
  302.         if (isset($request->request)) {
  303.             $entityManager = $this->getDoctrine()->getManager();
  304.             $risque =$entityManager->getRepository(Risque::class)->findAll();
  305.             
  306.             // Déterminer l'entité à filtrer
  308.             $selectedEntity = $this->selectedEntityService->getSelectedEntity();
  309.             $situations_risques = $situation->getSituationRisques();
  310.             $data = [];
  311.             
  312.             foreach ($situations_risques as $situation_risque) {
  313.                 // Filtrer par entité sélectionnée ou montrer tout si aucune entité sélectionnée
  314.                 if (
  315.                     !$selectedEntity ||
  316.                     !$situation_risque->getCompanyEntity() ||
  317.                     $situation_risque->getCompanyEntity()->getId() === $selectedEntity->getId()
  318.                 ) {
  319.                     $data[] = [
  320.                         'idSR'=>$situation_risque->getId(),
  321.                         'titlerisque'=>$situation_risque->getRisque()->getNom(),
  322.                         'idRisque'=>$situation_risque->getRisque()->getId(),
  323.                         'idSituation'=>$situation->getId(),
  324.                     ];
  325.                 }
  326.             }
  327.             $response =$data;
  328.             return new JsonResponse($response, 200);
  329.         }
  330.     }
  331.     /**
  332.      * @Route("/task/{id}/delete", name="task_job_delete", methods={"GET","POST"})
  333.      */
  334.     public function deleteT(Request $request, Task $tache): Response
  335.     {
  336.         return $this->deletedata($request, $tache, 'T');
  337.     }
  338.     /**
  339.      * @Route("/situation/{id}/delete", name="situation_delete", methods={"GET","POST"})
  340.      */
  341.     public function deleteS(Request $request, Situation $situation): Response
  342.     {
  343.         return $this->deletedata($request, $situation, 'S');
  344.     }
  345.     public function deletedata($request, $data, $type): Response
  346.     {
  347.         if (isset($request->request)) {
  348.             $entityManager = $this->getDoctrine()->getManager();
  349.             if ($type=='T') {
  350.                 $situations = $entityManager->getRepository(Situation::class)->findBy(['task'=>$data->getId()]);
  352.                 foreach ($situations as $situation) {
  353.                     $situations_risques = $entityManager->getRepository(SituationRisque::class)->findBy(['situation'=>$situation->getId()]);
  354.                     foreach ($situations_risques as $situation_risque) {
  355.                         $actions = $situation_risque->getActions();
  356.                         foreach ($actions as $action) {
  357.                             $entityManager->remove($action);
  358.                         }
  359.                         $entityManager->remove($situation_risque);
  360.                         $entityManager->flush();
  361.                     }
  362.                     $entityManager->remove($situation);
  363.                     $entityManager->flush();
  364.                 }
  365.             } elseif ($type=='S') {
  366.                 $situations_risques = $entityManager->getRepository(SituationRisque::class)->findBy(['situation'=>$data->getId()]);
  367.                 foreach ($situations_risques as $situation_risque) {
  368.                     $entityManager->remove($situation_risque);
  369.                     $entityManager->flush();
  370.                 }
  371.             }
  372.             $entityManager->remove($data);
  373.             $entityManager->flush();
  374.             $response =['deleted'=>1];
  375.                     
  376.             return new JsonResponse($response, 200);
  377.         }
  378.     }
  379.     /**
  380.      * @Route("/criticite/{id}/edit", name="edit_criticite", methods={"GET","POST"})
  381.      */
  382.     public function editCriticite(Request $request, SituationRisque $situationRisque): Response
  383.     {
  384.         if (!$request->isXmlHttpRequest()) {
  385.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  386.         }
  387.         if (isset($request->request)) {
  388.             $entityManager = $this->getDoctrine()->getManager();
  389.             $listF= $entityManager->getRepository(Frequence::class)->findAll();
  390.             $listG= $entityManager->getRepository(Gravite::class)->findAll();
  391.             // dd($situationRisque);
  392.             $frequenceId=0;
  393.             $graviteId =0;
  394.              if ($situationRisque->getFrequence())
  395.             $frequenceId=$situationRisque->getFrequence()->getId();
  396.             if ($situationRisque->getGravite())
  397.             $graviteId=$situationRisque->getGravite()->getId();
  398.             $commentaire=$situationRisque->getCommentCR();
  399.             $idSR=$situationRisque->getId();
  400.             return $this->render('bilanTemplates/identification_sst/_formCR.html.twig', [
  401.             'frequenceId' => $frequenceId,
  402.             'graviteId' => $graviteId,
  403.             'commentaire'=> $commentaire,
  404.             'id'=>$idSR,
  405.             'frequences'=>$listF,
  406.             'gravites'=>$listG,
  407.             'type'=>'SSTmetier',
  408.         ]);
  409.         }
  410.     }
  411.     /**
  412.      * @Route("/prevention/{id}/edit", name="edit_prevention", methods={"GET","POST"})
  413.      */
  414.     public function editPrevention(Request $request, SituationRisque $situationRisque): Response
  415.     {
  416.         if (!$request->isXmlHttpRequest()) {
  417.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  418.         }
  419.         if (isset($request->request)) {
  420.             $entityManager = $this->getDoctrine()->getManager();
  421.             $listMOG= $entityManager->getRepository(MOG::class)->findAll();
  422.             $mogId =0;
  423.             if ($situationRisque->getMOG())
  424.             $mogId=$situationRisque->getMOG()->getId();
  425.             $commentaire=$situationRisque->getCommentRR();
  426.             $idSR=$situationRisque->getId();
  427.             return $this->render('bilanTemplates/identification_sst/_formRR.html.twig', [
  428.             'mogId' => $mogId,
  429.             'commentaire'=> $commentaire,
  430.             'id'=>$idSR,
  431.             'mogs'=>$listMOG,
  432.             'type'=>'SSTmetier',
  433.         ]);
  434.         }
  435.     }
  436.     /**
  437.      * @Route("/saveCrticite", name="saveCrticite", methods={"GET","POST"})
  438.      */
  439.     public function saveCrticite(Request $request,TaskRepository $taskRepository): Response
  440.     {
  441.         if (!$request->isXmlHttpRequest()) {
  442.             return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  443.         }
  444.         if (isset($request->request)) {
  445.             $idSR = $request->request->get('id');
  446.             $evaluer =  $request->request->get('evaluer');
  447.            
  448.             $commentaire= $request->request->get('commentaire');
  449.             $entityManager = $this->getDoctrine()->getManager();
  450.             $situation_risque = $entityManager->getRepository(SituationRisque::class)->findOneBy(['id'=>$idSR]);
  451.             if ($evaluer=='criticite') {
  452.                 $idF= $request->request->get('frequence');
  453.                 $idG= $request->request->get('gravite');
  454.                 $frequence = $entityManager->getRepository(Frequence::class)->findOneBy(['id'=> substr($idF, strpos($idF, "_") + 1)]);
  455.            
  456.                 $gravite = $entityManager->getRepository(Gravite::class)->findOneBy(['id'=>substr($idG, strpos($idG, "_") + 1)]);
  457.                 //old
  458.                 //$criticite_array = $entityManager->getRepository(Criticite::class)->findBy(['type'=>'criticite']);
  459.                 //updated by Chiheb
  460.                 $criticite_array = $entityManager->getRepository(Criticite::class)->findBy(['type'=>'criticite'],['valeur'=>'asc']);
  461.                 $situation_risque->setFrequence($frequence);
  462.                 $situation_risque->setGravite($gravite);
  463.                 $situation_risque->setCommentCR($commentaire);
  464.               
  465.                 try {
  466.                     $entityManager->flush();
  467.                     $noteF=$frequence->getNote();
  468.                     $noteG=$gravite->getNote();
  469.                     $criticiteValue=$noteF*$noteG;
  470.                     //old
  471.                     // usort($criticite_array, function ($a, $b) {
  472.                     //     return strcmp($a->getValeur(), $b->getValeur());
  473.                     // });
  474.                      $criticite='';
  475.                      $criticite_color='#fff';
  476.                     foreach ($criticite_array as $criticite_element) {
  477.                         if ($criticiteValue  >=$criticite_element->getValeur()) {
  478.                             $criticite=$criticite_element->getLegende();
  479.                             $criticite_valeur=$criticite_element->getValeur();
  480.                             $criticite_color=$criticite_element->getCouleur();
  481.                         }
  482.                     }
  483.                     
  484.                     $data =array('id' => $situation_risque->getId(),'frequence'=>$noteF,'gravite'=>$noteG,'criticiteVal'=> $criticiteValue,'criticiteLegende'=>$criticite,'criticiteColor'=>$criticite_color);
  485.                 } catch (\Exception $e) {
  486.                     $data = array('status' => 'error', 'message' => $e->getMessage());
  487.                 }
  488.             }
  489.              if ($evaluer=='prevention') {
  490.                 $idmog= $request->request->get('mog');
  491.                 $mog = $entityManager->getRepository(MOG::class)->findOneBy(['id'=> substr($idmog, strpos($idmog, "_") + 1)]);
  492.                 $prevention_array = $entityManager->getRepository(Criticite::class)->findBy(['type'=>'prevention'],['valeur'=>'asc']);
  493.               
  494.                 $situation_risque->setMOG($mog);
  495.                 $situation_risque->setCommentRR($commentaire);
  496.               
  497.                 try {
  498.                     $entityManager->flush();
  499.                     $noteMog=$mog->getNote();
  500.                     $noteF =  $situation_risque->getFrequence()->getNote();
  501.                     $noteG =  $situation_risque->getGravite()->getNote();
  502.                    
  503.                     $preventionVal=$taskRepository->calculRR(0, $noteMog, $noteF, $noteG);
  504.                      $prevention='';
  505.                      $prevention_color='#fff';
  506.                     foreach ($prevention_array as $prevention_element) {
  507.                         if ($preventionVal  >=$prevention_element->getValeur()) {
  508.                             $prevention=$prevention_element->getLegende();
  509.                             $prevention_valeur=$prevention_element->getValeur();
  510.                             $prevention_color=$prevention_element->getCouleur();
  511.                         }
  512.                     }
  513.                     $data =array('id' => $situation_risque->getId(),'mog'=>$noteMog,'preventionVal'=> $preventionVal,'preventionLegende'=>$prevention,'preventionColor'=>$prevention_color);
  514.                 } catch (\Exception $e) {
  515.                     $data = array('status' => 'error', 'message' => $e->getMessage());
  516.                 }
  517.             }
  518.         }
  519.             $response =$data;
  520.             return new JsonResponse($response, 200);
  521.     }
  522.      /**
  523.     * @Route("/mEtudier", name="metier_etudier",methods={"POST"})
  524.     */
  525.     public function mEtudier(Request $request,JobRepository $jobRepository): Response
  526.     {
  527.         if (isset($request->request)) {
  528.             $entityManager = $this->getDoctrine()->getManager();
  529.             $metiers = $jobRepository->countAll();
  530.             $metierST= $jobRepository->countMEtudier($request->request->get('company_entity_id'));
  531.             $mEtudiers=($metierST/$metiers)*100;
  532.             $data =array('mEtudiers'=>$mEtudiers);
  533.             $response =$data;
  534.             return new JsonResponse($response, 200);
  535.         }
  537.         return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
  538.     }
  539. }