src/Controller/ProcessusController.php line 723

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Activity;
  6. use App\Entity\Comments;
  7. use App\Entity\Folder;
  8. use App\Entity\Indicator;
  9. use App\Entity\Processus;
  10. use App\Entity\Reunion;
  11. use App\Entity\Source;
  12. use App\Entity\Type;
  13. use App\Enum\StatusEnum;
  14. use App\Form\ConfigProcessusType;
  15. use App\Form\ProcessusType;
  16. use App\Repository\ActionRepository;
  17. use App\Repository\ReunionRepository;
  18. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\Routing\Annotation\Route;
  22. use App\Utils\Utility;
  23. use App\Notification\SendNotification;
  24. use App\Repository\ActivityRepository;
  25. use App\Repository\DataRepository;
  26. use App\Repository\IndicatorRepository;
  27. use App\Security\ProcessusVoter;
  28. use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
  29. use Symfony\Component\Filesystem\Filesystem;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  31. use Symfony\Component\Security\Core\Security;
  33. /**
  34.  * @Route("/processus")
  35.  */
  36. class ProcessusController extends AbstractController
  37. {
  38.     /**
  39.      * @var SendNotification
  40.      */
  41.     private $notify;
  42.     private $security;
  44.     public function __construct(SendNotification $notify, Security $security)
  45.     {
  46.         $this->notify = $notify;
  47.         $this->security = $security;
  48.     }
  50.     /**
  51.      * @Route("/", name="processus_index", methods={"GET"})
  52.      */
  53.     public function index(): Response
  54.     {
  55.         $processuses = $this->getDoctrine()
  56.             ->getRepository(Processus::class)
  57.             ->findAll();
  58.         //menu 
  59.         $menu="processus";
  60.         $left_menu="system_management";
  61.         
  62.         return $this->render('processus/index.html.twig', [
  63.             'processuses' => $processuses,
  64.             'menu'=>$menu,
  65.             'left_menu'=>$left_menu
  66.         ]);
  67.     }
  68.       /**
  69.      * @Route("/configuration", name="config_processus", methods={"GET"})
  70.      */
  71.     public function config_processus(Request $request): Response
  72.     {
  73.         $processuses = $this->getDoctrine()
  74.             ->getRepository(Processus::class)
  75.             ->findAll();
  77.         $form = $this->createForm(ConfigProcessusType::class);
  78.         $form->handleRequest($request);
  80.         if ($form->isSubmitted() && $form->isValid()) {
  81.         
  83.             return $this->redirectToRoute('processus_index');
  84.         }
  86.         //menu 
  87.         $menu="processus";
  88.         $left_menu="configuration";
  89.         
  90.         return $this->render('processus/configuration.html.twig', [
  91.             'processuses' => $processuses,
  92.             'menu'=>$menu,
  93.             'left_menu'=>$left_menu, 
  94.             'form' => $form->createView(),
  95.         ]);
  96.     }
  98.     /**
  99.      * @Route("/new/{type}", name="processus_new", methods={"GET","POST"})
  100.      */
  101.     public function new(Request $request, String $type): Response
  102.     {
  103.         $this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CRU);
  104.         
  105.         $processuss = $this->getDoctrine()
  106.             ->getRepository(Processus::class)
  107.             ->findAll();
  108.         $array_ref=[];
  109.          foreach ($processuss as $proc) {
  110.            $array_ref[]=$proc->getRef();
  111.          }
  112.         
  113.         $processus = new Processus();
  114.         $user= $this->getUser();
  115.         /* genretate ref */
  116.         /*$lastId=0;
  117.         $lastprocessus = $this->getDoctrine()->getRepository(processus::class)->findOneBy([], ['id' => 'desc']);
  118.         if(is_object($lastprocessus))
  119.         {
  120.             $lastId = $lastprocessus->getId();
  121.         }
  122.         $utility = new Utility;
  123.         $ref = $utility->generateRef($lastId,processus::PREFIX,'processus');
  124.         $processus->setRef($ref);*/
  125.         /* end genretate ref*/
  126.         
  127.         $processus ->setType($type);
  128.         $form = $this->createForm(processusType::class, $processus);
  129.         $form->handleRequest($request);
  130.         if ($form->isSubmitted() && $form->isValid()) {
  131.             $ref_exsist = $this->getDoctrine()->getRepository(Processus::class)->findOneBy(['ref'=>$processus->getRef()]);
  132.             if (empty($ref_exsist)) {
  136.                 $processus->setCreatedAt(new \DateTime('now'));
  137.                 
  138.                 $processus->setCreatedBy($user);
  139.                 $processus->addParticipant($user);
  140.                 if($processus->getPilote()) {
  142.                     $processus->addParticipant($processus->getPilote());
  143.                 }
  145.                 $processus->setRef($processus->getRef());
  147.                 $is_outsourced = boolval($request->request->get('is_outsourced'));
  148.                 $processus->setIsOutsourced($is_outsourced);
  149.                 if($is_outsourced) {
  150.                     $processus->setPilote(null);
  151.                 }else {
  152.                     $processus->setExternalCompany('');
  153.                     $processus->setContactPerson('');
  154.                 }
  156.                 // add comment dashboard
  157.                 $comment =  new Comments();
  158.                 $comment->setCreatedBy($processus->getCreatedBy());
  159.                 $comment->setProcessus($processus);
  164.                 //create folder in ged directory
  165.                 $entityManager = $this->getDoctrine()->getManager();
  166.                 $folderCommun = $entityManager->getRepository(Folder::class)->findOneBy(["folderName"=>"Documents Communs","path"=>"/"]);
  167.             
  168.                 if (empty($folderCommun)) {
  169.                     $folderCommun = new Folder();
  170.                     $folderCommun->setFolderName("Documents Communs");
  171.                     $folderCommun->setFolderType("Documents Communs");
  172.                     $folderCommun->setPath("/");
  173.                 }
  176.                 $folder = new Folder();
  177.                 $folder->setFolderName($processus->getTitle()) ;
  178.                 $folder->setParentFolder($folderCommun) ;
  179.                 $folder->setFolderType("Documents Communs") ;
  180.                 $folder->setProcessus($processus);
  181.                 $folder->setPath("/Documents Communs/");
  183.                 /*$fsObject = new Filesystem();
  184.                 $current_dir_path = getcwd();
  185.                 try {
  186.                     $Commun_dir_path = $current_dir_path . "/Files/Ged_Files/".$folderCommun->getFolderName()."/".$folder->getFolderName();
  188.                     if (!$fsObject->exists($Commun_dir_path))
  189.                     {
  190.                         $old = umask(0);
  191.                         $fsObject->mkdir($Commun_dir_path, 0775);
  192.                         $fsObject->chown($Commun_dir_path, "www-data");
  193.                         $fsObject->chgrp($Commun_dir_path, "www-data");
  194.                         umask($old);
  195.                     }
  196.                 } catch (IOExceptionInterface $exception) {
  197.                     echo "Error creating directory at". $exception->getPath();
  198.                 }*/
  200.             
  202.             
  203.                 $entityManager->persist($processus);
  204.                 $entityManager->persist($comment);
  205.                 if (empty($folderCommun)) {
  206.                     $entityManager->persist($folderCommun);
  207.                 }
  208.                 $entityManager->persist($folder);
  209.                 $entityManager->flush();
  211.                 // $this->notify->notify(
  212.                 //     $processus->getCreatedBy()->getEmail(),
  213.                 //     $processus->getPilote()->getEmail(),
  214.                 //     $processus->getPilote()->getFullName(),
  215.                 //     $processus->getRef()
  216.                 // );
  219.             
  220.             
  221.                 $this->addFlash("success", "Le processus a été créé avec succès");
  222.                 return $this->redirectToRoute('processus_index');
  223.             }else{
  224.                  $response = array('error' => 'Cette référence exsiste déjà !');
  225.                  return new JsonResponse($response,200); 
  226.                
  227.             }
  229.         }
  231.         return $this->render('processus/new.html.twig', [
  232.             'processuss'=>$array_ref,
  233.             'processus' => $processus,
  234.             'form' => $form->createView(),
  235.         ]);
  236.     }
  238.     /**
  239.      * @Route("/{id}", name="processus_show", methods={"GET"})
  240.      */
  241.     public function show(Processus $processus): Response
  242.     {
  243.         //menu 
  244.         $menu="processus";
  245.         $left_menu="system_management";
  246.         return $this->render('processus/show.html.twig', [
  247.             'processus' => $processus,
  248.             'menu' => $menu,
  249.             'left_menu' => $left_menu
  250.         ]);
  251.     }
  253.     /**
  254.      * @Route("/{id}/edit", name="processus_edit", methods={"GET","POST"})
  255.      */
  256.     public function edit(Request $request, Processus $processus): Response
  257.     {   
  258.         
  259.          $processuss = $this->getDoctrine()
  260.         ->getRepository(Processus::class)
  261.         ->findAll();
  262.         $array_ref=[];
  263.         foreach ($processuss as $proc) {
  264.                 $array_ref[]=$proc->getRef();
  265.                     }
  266.         $form = $this->createForm(ProcessusType::class, $processus);
  267.         $form->handleRequest($request);
  269.         if ($form->isSubmitted() && $form->isValid()) {
  270.             $this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CRU);
  271.             $processus->setUpdatedAt(new \DateTime('now'));
  273.             $is_outsourced = boolval($request->request->get('is_outsourced'));
  274.             
  275.             $processus->setIsOutsourced($is_outsourced);
  276.             if($is_outsourced) {
  277.                 $processus->setPilote(null);
  278.             }else {
  279.                 $processus->setExternalCompany('');
  280.                 $processus->setContactPerson('');
  281.             }
  283.             $this->getDoctrine()->getManager()->flush();
  284.             $this->addFlash("success","Le processus a été modifié avec succès");
  286.             return $this->redirectToRoute('processus_index');
  287.         }
  289.         return $this->render('processus/edit.html.twig', [
  290.             'processuss' => $array_ref,
  291.             'processus' => $processus,
  292.             'form' => $form->createView(),
  293.         ]);
  294.     }
  296.     /**
  297.      * @Route("/{id}/ficheedit", name="processus_fiche_edit", methods={"GET","POST"})
  298.      */
  299.     public function ficheedit(Request $request, Processus $processus): Response
  300.     {
  301.         $this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CRU);
  302.         $form = $this->createForm(ProcessusType::class, $processus);
  303.         $form->handleRequest($request);
  305.         if ($form->isSubmitted() && $form->isValid()) {
  306.             $processus->setUpdatedAt(new \DateTime('now'));
  307.             $this->getDoctrine()->getManager()->flush();
  308.             $this->addFlash("success","Le processus a été modifié avec succès");
  310.             return $this->redirectToRoute('processus_show',['id'=>$processus->getId()]);
  311.         }
  313.         return $this->render('processus/ficheedit.html.twig', [
  314.             'processus' => $processus,
  315.             'form' => $form->createView(),
  316.         ]);
  317.     }
  319.     /**
  320.      * @Route("/{id}", name="processus_delete", methods={"POST"})
  321.      */
  322.     public function delete(Request $request, Processus $processus): Response
  323.     {
  324.         $this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_D);
  325.         if ($this->isCsrfTokenValid('delete'.$processus->getId(), $request->request->get('_token'))) {
  326.             $entityManager = $this->getDoctrine()->getManager();
  327.             $entityManager->remove($processus);
  328.             $this->addFlash("success","Le processus a été supprimé avec succès");
  329.             $entityManager->flush();
  330.             
  331.         }
  332.         return $this->redirectToRoute('processus_index');
  333.         
  334.     }
  336.     /**
  337.      * @Route("/dashboardProcessus/{id}", name="dashboard_processus_signle")
  338.      */
  339.     public function dashboardProcessus(ActionRepository $actionRepository, Processus $processus, ReunionRepository $reunionRepository)
  340.     {
  341.         $utility = new Utility;
  342.        
  343.         
  344.         $nbrTotalAction = $actionRepository->findNbrAction($processus);
  345.         
  348.         //indicator objectif
  349.         $indicators = $this->getDoctrine()
  350.             ->getRepository(Indicator::class)
  351.             ->findBy(['processus'=>$processus,'type'=>'OBJECTIF STRATEGIQUE','status'=>Indicator::STATUS_VALIDATED]);
  353.         
  355.         $array_indicators_values=[];
  356.         
  357.         if($indicators)
  358.         {
  359.             foreach($indicators as $indicator)
  360.             {
  361.                 $cible = $indicator->getCible();
  362.                 
  363.                 foreach ($indicator->getIndicatorValues() as $indicatorValue) 
  364.                 {
  365.                     $array_indicator_value=[];
  366.                     $departValue = $indicatorValue->getJan();
  367.                     $ecart = $cible - $departValue;
  369.                     
  371.                     $color_parts_array=  $utility->random_rgb_color_array();
  372.                     $array_indicator_value['name']=$indicator->getTitle();
  374.                     $array_indicator_value['fillColor']= $utility->generate_rgb_color($color_parts_array,0.2);
  375.                     $array_indicator_value['color']= $utility->generate_rgb_color($color_parts_array,1);
  377.                     $array_indicator_value['Jan'] = $utility->getPercentage(($indicatorValue->getJan() - $departValue),$ecart);
  378.                     $array_indicator_value['Feb'] = $utility->getPercentage(($indicatorValue->getFeb() - $departValue),$ecart);
  379.                     $array_indicator_value['Mar'] = $utility->getPercentage(($indicatorValue->getMar() - $departValue),$ecart);
  380.                     $array_indicator_value['Apr'] = $utility->getPercentage(($indicatorValue->getApr() - $departValue),$ecart);
  381.                     $array_indicator_value['Mai'] = $utility->getPercentage(($indicatorValue->getMai() - $departValue),$ecart);
  382.                     $array_indicator_value['Jun'] = $utility->getPercentage(($indicatorValue->getJun() - $departValue),$ecart);
  383.                     $array_indicator_value['Jul'] = $utility->getPercentage(($indicatorValue->getJul() - $departValue),$ecart);
  384.                     $array_indicator_value['Aug'] = $utility->getPercentage(($indicatorValue->getAug() - $departValue),$ecart);
  385.                     $array_indicator_value['Sep'] = $utility->getPercentage(($indicatorValue->getSep() - $departValue),$ecart);
  386.                     $array_indicator_value['Oct'] = $utility->getPercentage(($indicatorValue->getOct() - $departValue),$ecart);
  387.                     $array_indicator_value['Nov'] = $utility->getPercentage(($indicatorValue->getNov() - $departValue),$ecart);
  388.                     $array_indicator_value['December'] = $utility->getPercentage(($indicatorValue->getDecember() - $departValue),$ecart);
  389.                     
  390.                     $array_indicators_values[]=$array_indicator_value;
  391.                     
  394.                 }
  395.                 
  396.                 
  397.             }
  398.         }
  399.         
  400.         
  401.         
  402.         //first Bar Chart
  403.         /*
  404.         $array_months=[
  405.             1   =>  "Janvier",
  406.             2   =>  "Février",
  407.             3   =>  "Mars",
  408.             4   =>  "Avril",
  409.             5   =>  "Mai",
  410.             6   =>  "Juin",
  411.             7   =>  "Juillet",
  412.             8   =>  "Août",
  413.             9   =>  "Septembre",
  414.             10  =>  "Octobre",
  415.             11  =>  "Novembre",
  416.             12  =>  "Décembre",
  417.         ];
  419.         
  420.         $array_individual_actions=[];
  421.         $array_objectif_actions=[];
  422.         $month_number = date('m');
  423.         $i=1;
  424.         for ($i=1; $i <= $month_number; $i++) {
  425.             $month_text= $array_months[$i];
  427.             $individual_actions=$actionRepository->findNbrAction($processus,'not_include',StatusEnum::STATUS_IN_PROGRESS,'late','','',$i);
  428.             
  429.             $array_individual_actions[$month_text]=$utility->getPercentage($individual_actions,$nbrTotalAction);
  431.             $objectif_actions=$actionRepository->findNbrAction($processus,'include',StatusEnum::STATUS_IN_PROGRESS,'late','','',$i);
  432.             
  433.             $array_objectif_actions[$month_text]=$utility->getPercentage($objectif_actions,$nbrTotalAction);
  434.         }
  435.         */
  436.         // chart source
  437.         $array_sources=[];
  438.         $sources = $this->getDoctrine()->getRepository(Source::class)->findAll();
  439.         
  440.         foreach($sources as $source )
  441.         {
  442.             $nbrActionSources=$actionRepository->findNbrAction($processus,'','','','','','','',$source);
  443.             $array_sources[$source->getTitle()]['value']=$utility->getPercentage($nbrActionSources,$nbrTotalAction);
  444.             $array_sources[$source->getTitle()]['color']=$utility->random_color();
  445.         }
  446.         $types = $this->getDoctrine()->getRepository(Type::class)->findAll();
  447.         $array_types=[];
  448.         foreach($types as $type )
  449.         {
  450.             $nbrActionTypes=$actionRepository->findNbrAction($processus,'','','','','','','','',$type);
  451.             $array_types[$type->getTitle()]['value']=$utility->getPercentage($nbrActionTypes,$nbrTotalAction);
  452.             $array_types[$type->getTitle()]['color']=$utility->random_color();
  453.         }
  454.         
  456.         //4 circles
  457.         
  458.         $nbrClosedLateAction = $actionRepository->findNbrAction($processus,'',StatusEnum::STATUS_CLOSED,'late');
  459.         $nbrPlannedActions_notStarted = $actionRepository->findNbrAction($processus,'',StatusEnum::STATUS_PLANNED,'','','','','','','','','','no');
  460.         $nbrOverBudgetAction = $actionRepository->findNbrAction($processus,'','','','','over');
  461.         $nbrActions_overDuration = $actionRepository->findNbrAction($processus,'','','','','','','','','','','','','over');
  463.         $nbrClosedLateActionPercent = $utility->getPercentage($nbrClosedLateAction,$nbrTotalAction);
  464.         $nbrPlannedActionsPercent = $utility->getPercentage($nbrPlannedActions_notStarted,$nbrTotalAction);
  465.         $nbrOverBudgetActionPercent = $utility->getPercentage($nbrOverBudgetAction,$nbrTotalAction);
  466.         $nbrActions_overDurationPercent = $utility->getPercentage($nbrActions_overDuration,$nbrTotalAction);
  469.         //next reunions
  470.         //months
  471.         $array_months=[
  472.             1   =>  "Janvier",
  473.             2   =>  "Février",
  474.             3   =>  "Mars",
  475.             4   =>  "Avril",
  476.             5   =>  "Mai",
  477.             6   =>  "Juin",
  478.             7   =>  "Juillet",
  479.             8   =>  "Août",
  480.             9   =>  "Septembre",
  481.             10  =>  "Octobre",
  482.             11  =>  "Novembre",
  483.             12  =>  "Décembre",
  484.         ];
  485.         $month_number = date('m');
  486.         $i=1;
  487.         $months=[];
  488.         for ($i=1; $i <= $month_number; $i++) {
  489.             $month_text= $array_months[$i];
  490.             $months[]=$month_text;
  491.         }
  492.         //reunion
  493.         $reunions = $reunionRepository->findByCustom($processus,'PLANIFIÉE',5);
  494.         
  495.         return $this->render('processus/dashboard.html.twig', [
  496.             'processus' => $processus,
  497.             //'individual_actions' => $array_individual_actions,
  498.             //'objectif_actions' => $array_objectif_actions,
  499.             'nbrClosedLateActionPercent' => $nbrClosedLateActionPercent,
  500.             'nbrPlannedActionsPercent' => $nbrPlannedActionsPercent,
  501.             'nbrOverBudgetActionPercent' => $nbrOverBudgetActionPercent,
  502.             'nbrActions_overDurationPercent' => $nbrActions_overDurationPercent,
  503.             'sources' => $array_sources,
  504.             'types' => $array_types,
  505.             'reunions' => $reunions,
  506.             'array_indicators_values'=>$array_indicators_values,
  507.             'months'=>$months
  508.         ]);
  510.         
  511.     }
  514.     /**
  515.      * @Route("identity/{id}", name="processus_identity", methods={"GET"})
  516.      */
  517.     public function processusIdentity(Processus $processus, IndicatorRepository $indicatorRepository, DataRepository $dataRepository, ActivityRepository $activityRepository): Response
  518.     {
  519.         //find data in    
  520.         $processus_in =[];
  521.         $indicators_in = $indicatorRepository->findIndicatorByRelatedProcessus($processus,'in');
  522.         foreach($indicators_in as $indicator)
  523.         {
  524.             $processusIn = $indicator->getProcessus();
  525.             if(!in_array($processusIn,$processus_in))
  526.             {
  527.                 $processus_in[]= $processusIn;
  528.             }
  529.         }
  530.         $doc_in = $dataRepository->findDataByRelatedProcessus($processus,'in');
  531.         foreach($doc_in as $doc)
  532.         {
  533.             $processusIn = $doc->getProcessus();
  534.             if(!in_array($processusIn,$processus_in))
  535.             {
  536.                 $processus_in[]= $processusIn;
  537.             }
  538.         }
  539.         $activities_in = $activityRepository->findActivityByRelatedProcessus($processus,'in');
  540.         foreach($activities_in as $activity)
  541.         {
  542.             $processusIn = $activity->getProcessus();
  543.             if(!in_array($processusIn,$processus_in))
  544.             {
  545.                 $processus_in[]= $processusIn;
  546.             }
  547.         }
  551.         // find out data
  553.         $processus_out =[];
  554.         $indicators_out = $indicatorRepository->findIndicatorByRelatedProcessus($processus,'out');
  555.         foreach($indicators_out as $indicator)
  556.         {
  557.             foreach($indicator->getProc() as $processusOut)
  558.             {
  559.                 if(!in_array($processusOut,$processus_out))
  560.                 {
  561.                     $processus_out[]= $processusOut;
  562.                 }
  563.             }
  564.         }
  565.         $doc_out = $dataRepository->findDataByRelatedProcessus($processus,'out');
  566.         foreach($doc_out as $doc)
  567.         {
  568.             foreach($doc->getProc() as $processusOut)
  569.             {
  570.                 if(!in_array($processusOut,$processus_out))
  571.                 {
  572.                     $processus_out[]= $processusOut;
  573.                 }
  574.             }
  575.         }
  576.         $activities_out = $activityRepository->findActivityByRelatedProcessus($processus,'out');
  577.         foreach($activities_out as $activity)
  578.         {
  579.             foreach($activity->getProcessusClients() as $processusOut)
  580.             {
  581.                 if(!in_array($processusOut,$processus_out))
  582.                 {
  583.                     $processus_out[]= $processusOut;
  584.                 }
  585.             }
  586.         }
  588.         //find activities
  589.         $activities = $this->getDoctrine()->getRepository(Activity::class)->findBy(['processus'=>$processus]);
  590.         // $processus_in = [];
  591.         // $indicators_in = [];
  592.         $doc_in = [];
  593.         // $processus_out = [];
  594.         // $indicators_out = [];
  595.         $doc_out = [];
  596.         // $activities = [];
  597.         return $this->render('processus/identity.html.twig', [
  598.             'processus' => $processus,
  599.             'processus_in' => $processus_in,
  600.             'indicators_in' => $indicators_in,
  601.             'doc_in' => $doc_in,
  602.             'processus_out' => $processus_out,
  603.             'indicators_out' => $indicators_out,
  604.             'doc_out' => $doc_out,
  605.             'activities' => $activities
  606.         ]);
  607.     }
  609.     /** 
  610.     * @Route("/all_processus/json",name="all_processus")
  611.     */
  612.     public function getAllProcessus():Response
  613.     {
  614.         $processus = $this->getDoctrine()->getRepository(Processus::class)->findAll();
  615.         $processusJson=[];
  616.         foreach($processus as $proc)
  617.         {
  618.             $processusJson[]=$proc->getTitle();
  619.         }
  620.         return new JsonResponse($processusJson);
  621.     }
  623.     /**
  624.      * @Route("/fiche-identite/{id}", name="processus_fiche_identite", methods={"GET"})
  625.      */
  626.     public function processus_fiche_identite(Processus $processus, IndicatorRepository $indicatorRepository, DataRepository $dataRepository, ActivityRepository $activityRepository)
  627.     {
  628.         
  629.         
  630.         //find data in    
  631.         $processus_in =[];
  632.         $indicators_in = $indicatorRepository->findIndicatorByRelatedProcessus($processus,'in');
  633.         foreach($indicators_in as $indicator)
  634.         {
  635.             $processusIn = $indicator->getProcessus();
  636.             
  637.             if(!in_array($processusIn,$processus_in))
  638.             {
  639.                 $processus_in[]= $processusIn;
  640.             }
  641.         }
  642.         $doc_in = $dataRepository->findDataByRelatedProcessus($processus,'in');
  643.         foreach($doc_in as $doc)
  644.         {
  645.             $processusIn = $doc->getProcessus();
  646.             if(!in_array($processusIn,$processus_in))
  647.             {
  648.                 $processus_in[]= $processusIn;
  649.             }
  650.         }
  651.         $activities_in = $activityRepository->findActivityByRelatedProcessus($processus,'in');
  652.         foreach($activities_in as $activity)
  653.         {
  654.             $processusIn = $activity->getProcessus();
  655.             if(!in_array($processusIn,$processus_in))
  656.             {
  657.                 $processus_in[]= $processusIn;
  658.             }
  659.         }
  663.         // find out data
  665.         $processus_out =[];
  666.         $indicators_out = $indicatorRepository->findIndicatorByRelatedProcessus($processus,'out');
  667.         foreach($indicators_out as $indicator)
  668.         {
  669.             foreach($indicator->getProc() as $processusOut)
  670.             {
  671.                 if(!in_array($processusOut,$processus_out))
  672.                 {
  673.                     $processus_out[]= $processusOut;
  674.                 }
  675.             }
  676.         }
  677.         $doc_out = $dataRepository->findDataByRelatedProcessus($processus,'out');
  678.         foreach($doc_out as $doc)
  679.         {
  680.             foreach($doc->getProc() as $processusOut)
  681.             {
  682.                 if(!in_array($processusOut,$processus_out))
  683.                 {
  684.                     $processus_out[]= $processusOut;
  685.                 }
  686.             }
  687.         }
  688.         $activities_out = $activityRepository->findActivityByRelatedProcessus($processus,'out');
  689.         foreach($activities_out as $activity)
  690.         {
  691.             foreach($activity->getProcessusClients() as $processusOut)
  692.             {
  693.                 if(!in_array($processusOut,$processus_out))
  694.                 {
  695.                     $processus_out[]= $processusOut;
  696.                 }
  697.             }
  698.         }
  700.         //find activities
  701.         $activities = $this->getDoctrine()->getRepository(Activity::class)->findBy(['processus'=>$processus]);
  702.         $doc_in = [];
  703.         $doc_out = [];
  704.         $menu="processus";
  705.         $left_menu="system_management";
  706.         return $this->render('processus/fiche_identite.html.twig', [
  707.             'processus' => $processus,
  708.             'processus_in' => $processus_in,
  709.             'indicators_in' => $indicators_in,
  710.             'doc_in' => $doc_in,
  711.             'processus_out' => $processus_out,
  712.             'indicators_out' => $indicators_out,
  713.             'doc_out' => $doc_out,
  714.             'activities' => $activities,
  715.             'menu'=>$menu,
  716.             'left_menu'=>$left_menu
  717.         ]);
  718.     }
  720.     /**
  721.      * @Route("/configuration/{id}", name="processus_configuration", methods={"GET"})
  722.      */
  723.     public function processus_configuration(Processus $processus) :Response
  724.     {
  725.         $menu="processus";
  726.         $left_menu="system_management";
  727.         return $this->render('processus/processus_configuration.html.twig', [
  728.             'processus' => $processus,
  729.             'menu'=>$menu,
  730.             'left_menu'=>$left_menu
  731.         ]);
  732.     }
  734.     /**
  735.      * @Route("/synthese/{id}", name="processus_synthese", methods={"GET"})
  736.      */
  737.     public function processus_synthese(Processus $processus) :Response
  738.     {
  739.         $menu="processus";
  740.         $left_menu="system_management";
  741.         return $this->render('processus/processus_synthese.html.twig', [
  742.             'processus' => $processus,
  743.             'menu'=>$menu,
  744.             'left_menu'=>$left_menu
  745.         ]);
  746.     }
  748.     /**
  749.      * @Route("/participants/{id}", name="processus_participants", methods={"GET"})
  750.      */
  751.     public function processus_participants(Processus $processus) :Response
  752.     {
  753.         $menu="processus";
  754.         $left_menu="system_management";
  755.         return $this->render('processus/participants.html.twig', [
  756.             'processus' => $processus,
  757.             'menu'=>$menu,
  758.             'left_menu'=>$left_menu
  759.         ]);
  760.     }
  761.     
  763. }