src/Controller/QuestionnairesController.php line 120

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\service\servicesGlobale;
  6. use App\Repository\QuestionnaireRepository;
  7. use App\Repository\QuestionsRepository;
  8. use App\Repository\ConfigHeaderRepository;
  9. use App\Repository\QuestionnaireProfileRepository;
  10. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  11. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  12. use Symfony\Component\HttpFoundation\Response;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Symfony\Component\Routing\Annotation\Route;
  16. use App\Entity\Questionnaire;
  17. use App\Entity\Questions;
  18. use App\Entity\QuestionReponse;
  19. use Symfony\Component\Filesystem\Filesystem;
  20. use Symfony\Component\Config\Definition\Exception\Exception;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use App\Repository\ProfilsRepository;
  23. use App\Entity\ReponseProfil;
  24. use App\Entity\QuestionnaireProfile;
  25. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  26. use App\Repository\SystemConfigurationRepository;
  31. class QuestionnairesController extends AbstractController
  32. {
  33.    private $etat_cnx ;
  35.     public function __construct(EntityManagerInterface $em , servicesGlobale $globalServ , SessionInterface $session )
  36.     {
  37.         
  38.         $this->em = $em ;
  39.         if(!$globalServ->verifSession()){
  40.             $this->etat_cnx = 0 ;
  41.         }
  42.         else{
  43.             $this->etat_cnx = 1 ;
  44.         }
  46.         $this->session = $session ;
  48.        
  49.     }
  50.     
  51.     function genererCode($length){
  52.         
  53.         $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  55.         $string = '';
  56.         for($i=0; $i<$length; $i++){
  57.             $string .= $chars[rand(0, strlen($chars)-1)];
  58.         }
  59.             
  60.         return $string;
  61.             
  62.     }
  63.     
  64.      /**
  65.      * @Route("/new_questionnaire", name="new_questionnaire", options = {"expose" = true})
  66.      * @Route("/qestionnaire_edit/{id}", name="qestionnaire_edit")
  67.      * @Route("/questionnaires", name="questionnaires", methods={"GET","POST"} , options={"expose"=true})
  68.      */
  70.     public function index(Request $request , QuestionnaireRepository $QuestionnaireRepository , 
  71.     ConfigHeaderRepository $ConfigHeaderRepository , ProfilsRepository $profilesRepository): Response
  72.     {
  73.         if($this->etat_cnx == 0 ){
  74.             return $this->redirectToRoute('login') ;
  75.         }
  76.         $questionnaires = $QuestionnaireRepository->findBy([], ['created_at' => 'DESC']);
  77.         $profiles = $profilesRepository->findAll();
  79.         $questionnaire = null ;
  80.         if(null !== $request->get('id')){
  81.             $questionnaire = $QuestionnaireRepository->find($request->get('id')) ;
  82.           
  83.         }
  84.         
  85.         return $this->render('questionnaires/index.html.twig', [
  86.             'questionnaires' => $questionnaires,
  87.             'questionnaire' => $questionnaire,
  88.             'profiles' => $profiles, 
  89.         ]);
  90.     }
  93.     /**
  94.      * @Route("/delete_questionnaire/{id}", name="delete_questionnaire", options={"expose"=true}, methods={"DELETE"})
  95.      */
  96.     public function deleteQuestionnaire(Request $request, Questionnaire $questionnaire): JsonResponse
  97.     {
  98.         $entityManager = $this->getDoctrine()->getManager();
  100.         //dd($questionnaire);
  102.         try {
  103.             $entityManager->remove($questionnaire);
  104.             $entityManager->flush();
  106.             // Return a success response
  107.             return new JsonResponse(['success' => true]);
  108.         } catch (\Exception $e) {
  109.             // Handle the exception, e.g., log the error
  111.             // Return an error response
  112.             return new JsonResponse(['success' => false, 'message' => 'Failed to delete the questionnaire']);
  113.         }
  114.     }
  117.     /**
  118.      * @Route("/quiz/{url}", name="quiz", methods={"GET","POST"}, options={"expose"=true})
  119.      */
  120.     public function showQuiz(Request $request, QuestionnaireRepository $QuestionnaireRepository, SystemConfigurationRepository $systemConfigurationRepository, ConfigHeaderRepository $ConfigHeaderRepository , $url): Response
  121.     {
  122.         $systemConfiguration = $systemConfigurationRepository->find(1);
  124.         $config_header = $ConfigHeaderRepository->find(2) ;
  125.   
  126.         //dd($config_header);
  128.         if ($systemConfiguration && $systemConfiguration->getMaintenance() && $this->etat_cnx == 0) {
  129.             return new Response('Dans un état de maintenance, revenez plus tard.', Response::HTTP_FORBIDDEN);
  130.         }
  131.         //dd($url);
  132.         $baseURL = 'https://akoyaconfig.services-unifies.fr/' . $url ;
  133.         $questionnaire = $QuestionnaireRepository->findOneBy(['url_questionnaire' => $url]);
  134.         if (!$questionnaire) {
  135.             throw $this->createNotFoundException('Questionnaire not found');
  136.         }
  138.         //dd($questionnaire->getQuestions()->toArray());
  140.         if ($questionnaire->getEtat() === 'disabled') {
  141.             return new Response('Questionnaire is disabled', Response::HTTP_FORBIDDEN);
  142.         }
  144.         //dd($questionnaire);
  145.     
  146.         return $this->render('questionnaires/frontOffice/quiz.html.twig', [
  147.             'questionnaire' => $questionnaire,
  148.             'HeaderGeneral' => $config_header->getContenu()
  149.         ]);
  150.     }
  153. /**
  154.  * @Route("/findProfile", name="findProfile", methods={"GET","POST"} , options={"expose"=true})
  155.  */
  156. public function findProfile(Request $request, QuestionnaireRepository $QuestionnaireRepository, ProfilsRepository $profilsRepository , SystemConfigurationRepository $systemConfigurationRepository): JsonResponse
  157. {
  158.     $requestData = json_decode($request->getContent(), true);
  159.     $profilePointsTotal = []; 
  160.     $systemConfiguration = $systemConfigurationRepository->find(1);
  161.     
  162.     foreach ($requestData as $responseIds) {
  163.         foreach ($responseIds as $responseId) {
  164.             $response = $this->getDoctrine()->getRepository(QuestionReponse::class)->find($responseId);
  166.             if ($response) {
  167.                 $responseProfilePoints = $response->getProfilePoints();
  168.                 
  169.                 foreach ($responseProfilePoints as $profilePoint) {
  170.                     $profileId = $profilePoint['id'];
  171.                     $profilePoints = intval($profilePoint['points']);               
  172.                     if (!isset($profilePointsTotal[$profileId])) {
  173.                         $profilePointsTotal[$profileId] = 0;
  174.                         //dump($profilePointsTotal[$profileId]);
  175.                     }
  176.                     $profilePointsTotal[$profileId] += $profilePoints;
  177.                 }
  178.             }
  179.         }
  180.     }
  182.     arsort($profilePointsTotal);
  183.     //dd($profilePointsTotal);
  186.     $topProfileIds = array_slice(array_keys($profilePointsTotal), 0, 6);
  187.     $testModeEnabled = $systemConfiguration ? $systemConfiguration->getModeTest() : false;
  190.     $profileDetails = [];
  191.     foreach ($topProfileIds as $profileId) {
  192.         $profile = $profilsRepository->findBy(['nom_profil' => $profileId]);
  193.         if ($profile) {
  194.             $profileDetails[] = [
  195.                 'profile' => $profile[0],
  196.                 'points' => $profilePointsTotal[$profileId],
  197.                 'testModeEnabled' => $testModeEnabled,
  198.             ];
  199.         }
  200.     }
  202.     //dd($profileDetails);
  204.      return $this->json($profileDetails);
  205. }
  214.  /**
  215.  * @Route("/save_questionnaire", name="save_questionnaire", methods={"POST"}, options={"expose"=true})
  216.  */
  217. public function saveQuestionnaire(
  218.     Request $request, 
  219.     QuestionnaireRepository $questionnaireRepository, 
  220.     EntityManagerInterface $em, 
  221.     QuestionsRepository $questionRepository, 
  222.     ProfilsRepository $profilsRepository): JsonResponse
  223. {
  225.     //dd($request->request->all());
  226.     try {
  227.     
  228.     $nomQuestionnaire = $request->request->get('nom_questionnaire');
  230.   
  231.    
  232.     $etat = $request->request->get('etat');
  233.     $profiles = $request->request->get('profiles');
  234.     $urlQuestionnaire = $request->request->get('url_questionnaire');
  235.     $meta = $request->request->get('meta');
  236.     $presentation = $request->request->get('presentation');
  237.     $header = $request->request->get('header');
  238.     $questionsData = json_decode($request->request->get('questions'), true);
  239.     //dd($request->request->all());
  240.     //dd($questionsData);
  241.     $codeCouleur = $request->request->get('code_couleur');
  242.     $couleurContraste = $request->request->get('couleur_contraste');
  245.     if (empty($questionsData['questions'])) {
  246.         return new JsonResponse(['error' => 'Vous devez ajouter au moins une question.'], Response::HTTP_BAD_REQUEST);
  247.     }
  248.     //dd($urlQuestionnaire);
  249.     $questionnaire = new Questionnaire();
  250.     $questionnaire->setNomQuestionnaire($nomQuestionnaire);
  251.     $questionnaire->setEtat($etat);
  252.     $questionnaire->setUrlQuestionnaire($urlQuestionnaire);
  253.     $questionnaire->setMetaDescription($meta);
  254.     $questionnaire->setPresentation($presentation);
  255.     $questionnaire->setHeader($header);
  256.     $questionnaire->setCodeCouleur($codeCouleur);
  257.     $questionnaire->setCouleurContraste($couleurContraste);
  258.     $questionnaire->setCreatedAt(new \DateTime());
  260.     //dd($urlQuestionnaire);
  261.     //$hashedUrl = md5($urlQuestionnaire);
  262.     //$questionnaire->sethashedURL($hashedUrl);
  264.     foreach ($profiles as $profileId) {
  265.         $profile = $profilsRepository->find($profileId);
  266.         if ($profile) {
  267.             $questionnaireProfile = new QuestionnaireProfile();
  268.             $questionnaireProfile->setQuestionnaire($questionnaire);
  269.             $questionnaireProfile->setProfil($profile);
  270.             $em->persist($questionnaireProfile);
  271.         }
  272.     }
  274.     $em->persist($questionnaire);
  276.     //dd($request->request->all());
  278.     foreach ($questionsData['questions'] as $questionData) {
  279.         $questionsEntity = new Questions();
  280.         $questionsEntity->setQuestion($questionData['text']);
  281.         $questionsEntity->setNomQuestionnaire($nomQuestionnaire);
  282.         $questionsEntity->setQuestionnaire($questionnaire); 
  283.         $questionsEntity->setNumResponses($questionData['numResponses']);
  285.         $em->persist($questionsEntity);
  287.         foreach ($questionData['responses'] as $response) {
  289.             $responseText = $response['text'];
  290.             
  291.             $questionReponse = new QuestionReponse(); 
  292.             $questionReponse->setQuestion($questionsEntity); 
  293.             $questionReponse->setContent($responseText);
  295.             $profilePoints = [];
  296.             foreach ($response['profiles'] as $profile) {
  297.                 $profileName = $profile['name'];
  298.                 $profileId = str_replace('input-', '', $profileName);
  299.                 $points = $profile['value'];
  300.                 
  301.                 $profilePoints[] = [
  302.                     'id' => $profileId,
  303.                     'points' => $points
  304.                 ];
  305.             }
  306.             $questionReponse->setProfilePoints($profilePoints);
  307.             
  310.             $em->persist($questionReponse); 
  311.         }
  312.     }
  313.     
  315.     $em->flush();
  317.     return new JsonResponse(['success' => true, 'questionnaire_id' => $questionnaire->getId()]);
  319.     } catch (\Exception $e) {
  320.         if (strpos($e->getMessage(), 'Duplicate entry') !== false) {
  321.             return new JsonResponse(['error' => 'Cette URL est déjà utilisée. Veuillez en choisir un différent.'], Response::HTTP_CONFLICT);
  322.         }
  323.         
  324.         return new JsonResponse(['error' => $e->getMessage()], Response::HTTP_INTERNAL_SERVER_ERROR);
  325.     }
  326. }
  329.  /**
  330.  * @Route("/upload_image", name="upload_image", methods={"POST"})
  331.  */
  332. public function upload_image(
  333.     Request $request,
  334.     QuestionnaireRepository $questionnaireRepository,
  335.     EntityManagerInterface $em,
  336.     Filesystem $filesystem
  337. ): JsonResponse {
  338.     // Load your questionnaire entity here (you need to replace 'Questionnaire' with your actual entity class)
  339.     $questionnaireId = $request->request->get('questionnaire_id');
  340.     $questionnaire = $questionnaireRepository->find($questionnaireId);
  342.     if (!$questionnaire) {
  343.         return $this->json(['status' => 'error', 'message' => 'Questionnaire not found']);
  344.     }
  346.     $uploadDirRoot = $this->getParameter('quiz_image_directory');
  348.     if (!$filesystem->exists($uploadDirRoot)) {
  349.         $filesystem->mkdir($uploadDirRoot);
  350.     }
  352.     $imageFile = $request->files->get('img_principale');
  354.     if ($imageFile !== null) {
  355.         $newFilename = uniqid().'.'.$imageFile->guessExtension();
  356.         $imageFile->move($uploadDirRoot, $newFilename);
  358.         $questionnaire->setImgPrincipale($newFilename);
  359.         $em->persist($questionnaire);
  360.         $em->flush();
  362.         return $this->json(['status' => 'success', 'message' => 'Image uploaded and questionnaire updated']);
  363.     } else {
  364.         return $this->json(['status' => 'error', 'message' => 'No image file uploaded']);
  365.     }
  366. } 
  371. /**
  372.  * @Route("/edit_questionnaire/{id}", name="edit_questionnaire", methods={"POST"}, options={"expose"=true})
  373.  */
  374. public function editQuestionnaire(
  375.     Request $request,
  376.     $id,
  377.     EntityManagerInterface $em,
  378.     QuestionsRepository $questionRepository,
  379.     ProfilsRepository $profilsRepository ,
  380.     QuestionnaireRepository $questionnaireRepository,
  381. ): JsonResponse {
  382.     $requestData = $request->request->all();
  383.     $questionsData = json_decode($requestData['questions'], true);
  385.     //dd($requestData);
  386.     $questionnaire = $em->getRepository(Questionnaire::class)->find($id);
  388.     if (!$questionnaire) {
  389.         return new JsonResponse(['error' => 'Questionnaire not found.'], 404);
  390.     }
  392.     //dd($requestData);
  393.    
  395.    // dd($request->files->get('img_principale'));
  396.    $uploadDirRoot = $this->getParameter('quiz_image_directory');
  397.     $imageFile = $request->files->get('img_principale');
  398.     $nomQuestionnaire = $requestData['editQuestionnaireName'];
  399.     $etat = $requestData['etat'];
  400.     //dd($etat);
  401.     $urlQuestionnaire = $requestData['editQuestionnaireURL'];
  402.     $metaDescription = $requestData['editQuestionnaireMetaDescription'];
  403.     $presentation = $requestData['editQuestionnairePresentation'];
  404.     $selectedProfilesJson = $requestData['selectedProfiles'];
  405.     $codeCouleur = $requestData['code_couleur'];
  406.     $contrastCouleur = $requestData['couleur_contraste'];
  407.     $selectedProfiles = json_decode($selectedProfilesJson, true);
  409.     /*
  410.     $existingQuestionnaire = $questionnaireRepository->findOneBy(['hashedURL' => $urlQuestionnaire]);
  412.     if ($existingQuestionnaire) {
  413.         $errorMessage = 'Cette URL est déjà utilisée. Veuillez en choisir une autre.';
  414.         return new JsonResponse(['error' => $errorMessage], 400);
  415.     }
  416.     */
  418.     
  419.     $questionnaire->setNomQuestionnaire($nomQuestionnaire);
  420.     $questionnaire->setEtat($etat);
  421.     $questionnaire->setUrlQuestionnaire($urlQuestionnaire);
  422.     $questionnaire->setMetaDescription($metaDescription);
  423.     $questionnaire->setPresentation($presentation);
  424.     $questionnaire->setCodeCouleur($codeCouleur);
  425.     $questionnaire->setCouleurContraste($contrastCouleur);
  429.    
  432.     //$questionnaire->sethashedURL($urlQuestionnaire);
  434.     if ($imageFile) {
  435.         $oldImageFilename = $questionnaire->getImgPrincipale(); 
  436.     
  437.         if ($oldImageFilename && file_exists($uploadDirRoot . $oldImageFilename)) {
  438.             unlink($uploadDirRoot . $oldImageFilename);
  439.         }
  440.     
  441.         $newFilename = uniqid().'.'.$imageFile->guessExtension();
  442.         $imageFile->move($uploadDirRoot, $newFilename);
  444.         $questionnaire->setImgPrincipale($newFilename);
  445.         $em->persist($questionnaire);
  446.         $em->flush();
  447.     }
  449.     //dd($request->request->all());
  451.     foreach ($questionnaire->getQuestionnaireProfiles() as $existingProfile) {
  452.         $questionnaire->removeQuestionnaireProfile($existingProfile);
  453.         $em->remove($existingProfile);
  454.     }
  455.     
  456.     foreach ($selectedProfiles as $profileName) {
  457.         $profile = $profilsRepository->findOneBy(['nom_profil' => $profileName]);
  458.     
  459.         if ($profile) {
  460.             $questionnaireProfile = new QuestionnaireProfile();
  461.             $questionnaireProfile->setQuestionnaire($questionnaire);
  462.             $questionnaireProfile->setProfil($profile);
  463.             $em->persist($questionnaireProfile);
  464.         }
  465.     }
  468.     if (isset($requestData['newQuestions'])) {
  469.         $newQuestionsData = json_decode($requestData['newQuestions'], true);
  470.         //dd($newQuestionsData);
  471.         foreach ($newQuestionsData as $newQuestionData) {
  472.             $newQuestionText = $newQuestionData['question'];
  473.             $numResponsesPossible = $newQuestionData['numResponsesPossible'];
  474.             //dd($numResponsesPossible);
  475.             $newQuestionEntity = new Questions();
  476.             $newQuestionEntity->setQuestion($newQuestionText);
  477.             $newQuestionEntity->setNomQuestionnaire($nomQuestionnaire);
  478.             $newQuestionEntity->setQuestionnaire($questionnaire);
  479.             $newQuestionEntity->setNumResponses($numResponsesPossible);
  480.             
  481.     
  482.             $em->persist($newQuestionEntity);
  483.     
  484.             foreach ($newQuestionData['reponses'] as $newResponse) {
  485.                 $newResponseText = $newResponse['content'];
  486.                 $newResponseEntity = new QuestionReponse();
  487.                 $newResponseEntity->setQuestion($newQuestionEntity);
  488.                 $newResponseEntity->setContent($newResponseText);
  489.     
  490.                 $profilePoints = [];
  491.                 foreach ($newResponse['profilePoints'] as $profilePoint) {
  492.                     $profileId = $profilePoint['id'];
  493.                     $points = $profilePoint['points'];
  494.                     $selectedProfile = $profilsRepository->findOneBy(['nom_profil' => $profileId]);
  495.     
  496.                     if ($selectedProfile) {
  497.                         $profilePoints[] = [
  498.                             'id' => $profileId,
  499.                             'points' => $points
  500.                         ];
  501.                     }
  502.                 }
  503.     
  504.                 $newResponseEntity->setProfilePoints($profilePoints);
  505.                 $em->persist($newResponseEntity);
  506.             }
  507.         }
  508.     
  509.         $em->flush();
  510.     }
  512.    
  513.     foreach ($questionsData as $questionData) {
  514.         $questionId = $questionData['id'];
  515.         $questionText = $questionData['question'];
  516.         $deleted = isset($questionData['deleted']) && $questionData['deleted'] === true; 
  517.         $question = $questionRepository->find($questionId);
  519.         $NombreReponse = $questionData['numResponses'];
  521.         //dd($NombreReponse);
  526.         if ($deleted) {
  527.             $question->removeReponse($questionReponse);
  528.             $em->remove($question);
  529.         }else{
  530.         $question->setQuestion($questionText);
  531.         $question->setNumResponses($NombreReponse);
  532.         foreach ($question->getReponses() as $questionReponse) {
  533.             $question->removeReponse($questionReponse);
  534.             $em->remove($questionReponse);
  535.         }
  536.         //$em->flush(); 
  537.     
  538.         foreach ($questionData['reponses'] as $response) {
  539.             $responseText = $response['content'];
  540.             $responseEntity = new QuestionReponse();
  541.             $responseEntity->setQuestion($question);
  542.             $responseEntity->setContent($responseText);
  543.     
  544.             $profilePoints = [];
  545.             //dd($response['profilePoints']);
  546.             foreach ($response['profilePoints'] as $profilePoint) {
  547.                
  548.                 $profileId = $profilePoint['id'];
  549.                 $points = $profilePoint['points'];
  550.                 $selectedProfile = $profilsRepository->findOneBy(['nom_profil' => $profileId]);
  551.                 //dd($points);
  552.                 //$points = $profile['value'];
  553.                 //dd($points);
  554.                 if ($selectedProfile) {
  555.                     $profilePoints[] = [
  556.                         'id' => $profileId, 
  557.                         'points' => $points
  558.                     ];
  559.                 }
  560.             }
  561.     
  562.             $responseEntity->setProfilePoints($profilePoints); 
  563.             $em->persist($responseEntity);
  564.         }
  565.         }
  566.         //$em->flush(); 
  567.     }
  568.     
  569.     $em->persist($questionnaire);
  570.     $em->flush();
  573.     return new JsonResponse(['success' => true]);
  574. }
  577.  
  582.       /**
  583.      * @Route("/module", name="module", options = {"expose" = true})
  584.      * @Route("/listeModules", name="listeModules", options = {"expose" = true})
  585.      * @Route("/module_edit/{id}", name="module_edit")
  586.      */
  587.     /* public function index2(Request $request , ModulesRepository $ModulesRepository  , GlobalAdmin $GlobalAdmin     , ConfigHeaderRepository $ConfigHeaderRepository  ): Response
  588.     {
  590.         if( ($this->session->get('susrD3p9LjjY86') != 'gA64ya3G5N') && ($request->hasSession()) ){
  592.             return $this->redirectToRoute('connexion');
  593.         }
  595.         $modules = $ModulesRepository->findAll() ;
  597.         $module = null ;
  598.         $pieces = null;
  599.         if(null !== $request->get('id')){
  600.             $module = $ModulesRepository->find($request->get('id')) ;
  601.             $pieces = $module->getPiecesJointes();
  602.           
  603.         }
  604.         
  606.        
  608.         $config_header = $ConfigHeaderRepository->findAll()[0];
  610.         return $this->render('modules/index.html.twig', [
  611.             'modules' => $modules ,
  612.             'module' => $module,
  613.             'config_header'=>$config_header,
  614.             'pieces'=>$pieces
  615.           
  616.         ]);
  617.         
  618.     }*/
  619. }