src\Controller\AdminController.php line 550

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Controller\Admin\DashboardController;
  6. use App\Controller\Admin\UserSurveyCrudController;
  7. use App\Entity\AdminStatus;
  8. use App\Entity\Document;
  9. use App\Entity\DocumentTypeTag;
  10. use App\Entity\EntityTypeTag;
  11. use App\Entity\Order;
  12. use App\Entity\Survey;
  13. use App\Entity\Tag;
  14. use App\Entity\User;
  15. use App\Entity\UserFile;
  16. use App\Entity\UserFileDocument;
  17. use App\Entity\UserFileMissingFiles;
  18. use App\Entity\UserFileProperty;
  19. use App\Entity\UserSurvey;
  20. use App\Entity\UserSurveyComment;
  21. use App\Entity\UserSurveyStatus;
  22. use App\Form\updateUserSurveyResultType;
  23. use App\Form\updateUserSurveyStatusType;
  24. use App\Form\UserFile\UserFileDocumentAskType;
  25. use App\Form\UserFile\UserFileDocumentTagsType;
  26. use App\Form\UserFile\UserFileMissingFilesType;
  27. use App\Form\UserFile\UserFileMissingFileType;
  28. use App\Form\UserFile\UserFilePersonInvalidCredentialType;
  29. use App\Form\UserSurvey\AFCType;
  30. use App\Form\UserSurvey\CMUDateType;
  31. use App\Form\UserSurvey\CMUResultType;
  32. use App\Form\UserSurvey\IFResultType;
  33. use App\Form\UserSurvey\RmbLppDateType;
  34. use App\Form\UserSurvey\SimulationType;
  35. use App\Form\UserSurvey\updateUserSurveyType;
  36. use App\Form\UserSurvey\UserSurveyDateLimitType;
  37. use App\Form\UserSurveyCommentType;
  38. use App\Service\BexioService;
  39. use App\Service\DiscountService;
  40. use App\Service\EmailService;
  41. use App\Service\LogService;
  42. use App\Service\PaymentService;
  43. use App\Service\PdfService;
  44. use App\Service\RsPdfService;
  45. use App\Service\UserSurveyQueryService;
  46. use App\Service\UserSurveyService;
  47. use App\Service\XmlService;
  48. use App\Service\XmlServiceQuasiResident;
  49. use DateTime;
  50. use Doctrine\ORM\EntityManagerInterface;
  51. use Doctrine\ORM\Tools\Pagination\Paginator;
  52. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  53. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  54. use Exception;
  55. use PhpParser\Comment\Doc;
  56. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  57. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  58. use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
  59. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  60. use Symfony\Component\HttpFoundation\JsonResponse;
  61. use Symfony\Component\HttpFoundation\RedirectResponse;
  62. use Symfony\Component\HttpFoundation\Request;
  63. use Symfony\Component\HttpFoundation\RequestStack;
  64. use Symfony\Component\HttpFoundation\Response;
  65. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  66. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  67. use Symfony\Component\Routing\Annotation\Route;
  68. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  70. /**
  71.  * Require ROLE_ADMIN for *every* controller method in this class.
  72.  *
  73.  * @Route("/admin", name="admin_")
  74.  * @IsGranted("ROLE_ADMIN")
  75.  */
  76. class AdminController extends DashboardController implements EventSubscriberInterface
  77. {
  78.     public EntityManagerInterface $em;
  79.     public RequestStack $request;
  80.     private EmailService $emailService;
  81.     private XmlService $xmlService;
  82.     private XmlServiceQuasiResident $xmlServiceQuasiResident;
  83.     private DiscountService $discountService;
  84.     private UserSurveyService $userSurveyService;
  85.     private UserSurveyQueryService $userSurveyQueryService;
  86.     private PdfService $pdfService;
  87.     private AdminUrlGenerator $adminUrlGenerator;
  88.     private LogService $logService;
  89.     private array $autorizedStatusForComplete;
  90.     private array $autorizedStatusForIncomplete;
  91.     private BexioService $bexioService;
  92.     private PaymentService $paymentService;
  94.     private RsPdfService $rsPdfService;
  96.     public function __construct(EmailService $emailService, XmlService $xmlService, XmlServiceQuasiResident $xmlServiceQuasiResident, DiscountService $discountService, UserSurveyService $userSurveyService, UserSurveyQueryService $userSurveyQueryService, PdfService $pdfService, EntityManagerInterface $entityManager, RequestStack $request, AdminUrlGenerator $adminUrlGenerator, LogService $logService, BexioService $bexioService, PaymentService $paymentService, RsPdfService $rsPdfService)
  97.     {
  98.         $this->emailService = $emailService;
  99.         $this->xmlService = $xmlService;
  100.         $this->xmlServiceQuasiResident = $xmlServiceQuasiResident;
  101.         $this->discountService = $discountService;
  102.         $this->userSurveyService = $userSurveyService;
  103.         $this->userSurveyQueryService = $userSurveyQueryService;
  104.         $this->pdfService = $pdfService;
  105.         $this->em = $entityManager;
  106.         $this->request = $request;
  107.         $this->adminUrlGenerator = $adminUrlGenerator;
  108.         $this->logService = $logService;
  109.         $this->paymentService = $paymentService;
  110.         $this->rsPdfService = $rsPdfService;
  112.         $this->autorizedStatusForComplete = ['PROCESSING_FILES_RECEIVED', 'PROCESSING_FILES_MISSING', 'PROCESSING_MISSING_FILES_SENT'];
  113.         $this->autorizedStatusForIncomplete = ['PROCESSING_FILES_RECEIVED', 'PROCESSING_FILES_MISSING', 'PROCESSING_MISSING_FILES_SENT'];
  114.         $this->bexioService = $bexioService;
  115.     }
  117.     public static function getSubscribedEvents()
  118.     {
  119.         return [];
  120.     }
  122.     /**
  123.      * @Route("/impersonate/{id}",name = "impersonate")
  124.      *
  125.      * @return Response
  126.      */
  127.     public function impersonate($id)
  128.     {
  129.         $user = $this->em->getRepository(User::class)->find($id);
  131.         if (!$user) {
  132.             throw new NotFoundHttpException();
  133.         }
  134.         // if (count($this->get('security.token_storage')->getToken()->getRoles()) > 2) {
  135.         if ($this->isGranted('IS_IMPERSONATOR')) {
  136.             return $this->redirectToRoute('admin_reimpersonate', [
  137.                 'id' => $id,
  138.                 '_switch_user' => '_exit',
  139.             ]);
  140.         }
  142.         return $this->redirectToRoute('espace_client_index', [
  143.             '_switch_user' => $user->getUserIdentifier(),
  144.         ]);
  145.     }
  147.     /**
  148.      * @Route("/admin/reimpersonate/{id}", name = "reimpersonate")
  149.      *
  150.      * @return RedirectResponse|Response
  151.      */
  152.     public function reimpersonateAction($id)
  153.     {
  154.         $user = $this->em->getRepository(User::class)->find($id);
  156.         if (!$user) {
  157.             throw new NotFoundHttpException();
  158.         }
  160.         return $this->redirectToRoute('espace_client_index', [
  161.             '_switch_user' => $user->getUserIdentifier(),
  162.         ]);
  163.     }
  165.     /**
  166.      * @return Response
  167.      */
  168.     public function exportUserSurveyCSVAction(Request $request)
  169.     {
  170.         $id = $request->query->get('id');
  172.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  174.         if (!$userSurvey) {
  175.             throw new NotFoundHttpException();
  176.         }
  178.         $fileName = 'export_csv_questionnaire_' . date('d_m_y') . '_' . $userSurvey->getId() . '.csv';
  179.         $file = $this->getParameter('webdir') . '/uploads/files/' . $fileName;
  180.         $fp = fopen($file, 'w');
  182.         // HEADER CONTENT
  183.         $fields = ['Prestation : ' . $userSurvey->conditionalSurveyName(), 'Client : ' . $userSurvey->getUser()->getFullName(), 'Statut : ' . $userSurvey->getSurveyStatusLabel()];
  184.         fputcsv($fp, $fields);
  185.         $fields = ['', '', ''];
  186.         fputcsv($fp, $fields);
  188.         // COLUMN
  189.         $fields = ['Groupes de questions', 'Questions', 'Réponses'];
  190.         fputcsv($fp, $fields);
  192.         foreach ($userSurvey->getUserSurveyQuestions() as $answer) {
  193.             $fields = [$answer->getQuestionGroup()->getName(), $answer->getQuestion()->getName()];
  195.             if ('FileType' == $answer->getQuestion()->getType()->getType() && '' != $answer->getValue() && !is_null($answer->getValue())) {
  196.                 $fields[] = $_ENV['ONLINE_BASE_PATH'] . '/uploads/files/' . $answer->getValue();
  197.             } else {
  198.                 $fields[] = $answer->getValue();
  199.             }
  201.             fputcsv($fp, $fields);
  202.         }
  204.         fclose($fp);
  205.         $content = utf8_decode(file_get_contents($file));
  206.         unlink($file);
  208.         $response = new Response($content);
  209.         $response->headers->set('Content-Type', 'text/csv');
  210.         $disposition = $response->headers->makeDisposition(
  211.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  212.             $fileName
  213.         );
  215.         $response->headers->set('Content-Disposition', $disposition);
  217.         return $response;
  218.     }
  220.     /**
  221.      * @Route("/admin/download/usersurvey/files/{id}", name = "download_usersurvey_files")
  222.      *
  223.      * @return Response
  224.      */
  225.     public function downloadUserSurveyFilesAction($id)
  226.     {
  227.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  229.         if (!$userSurvey) {
  230.             throw new NotFoundHttpException();
  231.         }
  232.         $userFile = $userSurvey->getUserFile();
  233.         $files = [];
  234.         foreach ($userFile->getUserFileDocuments() as $document) {
  235.             $files[] = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/' . $document->getFileName();
  236.         }
  238.         if (!empty($files)) {
  239.             $zip = new \ZipArchive();
  241.             // The name of the Zip documents.
  242.             $zipName = $this->getParameter('webdir') . '/uploads/files/Documents_' . $userSurvey->getId() . '.zip';
  244.             $zip->open($zipName, \ZipArchive::CREATE);
  245.             foreach ($files as $file) {
  246.                 // $zip->addFromString(basename($file),  file_get_contents($file));
  247.                 $zip->addFile($file, basename($file));
  248.             }
  249.             $zip->close();
  251.             $response = new Response(file_get_contents($zipName));
  252.             $response->headers->set('Content-Type', 'application/zip');
  253.             $response->headers->set('Content-Disposition', 'attachment;filename="Documents_' . $userSurvey->getId() . '.zip"');
  254.             $response->headers->set('Content-length', filesize($zipName));
  256.             @unlink($zipName);
  258.             return $response;
  259.         } else {
  260.             $this->addFlash('danger', 'Aucun fichier à télécharger pour cette prestation.');
  261.             $url = $this->adminUrlGenerator
  262.                 ->setController(UserSurveyCrudController::class)
  263.                 ->setAction(Action::INDEX)
  264.                 ->generateUrl();
  266.             return $this->redirect($url);
  267.         }
  268.     }
  270.     /**
  271.      * @Route("/admin/getax/generate/file/{userSurveyId}", name = "getax_generate_file", requirements={"userSurveyId"="\d+"})
  272.      *
  273.      * @return Response
  274.      */
  275.     public function generateGetaxFileAction(Request $request, int $userSurveyId = 0)
  276.     {
  277.         if (0 == $userSurveyId) {
  278.             $userSurveyId = $request->get('id');
  279.         }
  281.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  283.         if (!$userSurvey) {
  284.             throw new NotFoundHttpException();
  285.         }
  287.         $baseUserSurvey = $userSurvey;
  288.         if (!is_null($userSurvey->getParent())) {
  289.             $baseUserSurvey = $userSurvey->getParent();
  290.         }
  292.         if ('QUASI_RESID' == $userSurvey->getSurvey()->getCode()) {
  293.             $xml = $this->xmlServiceQuasiResident->generateGetaxXmlFile($userSurvey);
  294.         } else {
  295.             $xml = $this->xmlService->generateGetaxXmlFile($baseUserSurvey);
  296.         }
  297.         file_put_contents($this->getParameter('webdir') . '/uploads/files/getax/xml/' . $userSurvey->getId() . '_' . $userSurvey->getUser()->getLastname() . $userSurvey->getUser()->getName() . (date('Y') - 1) . '_' . date('d_m_y_h_i') . '.xml', $xml);
  299.         $this->addFlash('success', 'Fichier Getax généré');
  301.         return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  302.     }
  304.     /**
  305.      * @Route("/admin/getax/download/file/{id}", name = "getax_download_file")
  306.      *
  307.      * @return Response
  308.      */
  309.     public function getGetaxTaxFileAction($id)
  310.     {
  311.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  313.         if (!$userSurvey) {
  314.             throw new NotFoundHttpException();
  315.         }
  317.         if ($userSurvey->hasGetaxFile($this->getParameter('webdir'))) {
  318.             $file = $this->getParameter('webdir') . '/uploads/files/getax/tax/' . $userSurvey->getId() . '_' . $userSurvey->getUser()->getLastname() . $userSurvey->getUser()->getName() . (date('Y') - 1) . '_' . date('d_m_y') . '.tax';
  319.             $response = new Response(file_get_contents($file));
  320.             $response->headers->set('Content-Type', 'application/xml');
  321.             $response->headers->set('Content-Disposition', 'attachment;filename="' . $userSurvey->getId() . '_' . $userSurvey->getUser()->getLastname() . $userSurvey->getUser()->getName() . (date('Y') - 1) . '_' . date('d_m_y') . '.tax' . '"');
  322.             $response->headers->set('Content-length', filesize($file));
  324.             return $response;
  325.         } else {
  326.             $this->addFlash('danger', 'Aucun fichier à télécharger pour cette prestation.');
  328.             $url = $this->adminUrlGenerator
  329.                 ->setController(UserSurveyCrudController::class)
  330.                 ->setAction(Action::INDEX)
  331.                 ->generateUrl();
  333.             return $this->redirect($url);
  334.         }
  335.     }
  337.     /**
  338.      * @Route("/admin/batchupdate/usersurvey/status/{ids}", name = "batch_usersurvey_status")
  339.      *
  340.      * @return RedirectResponse|Response
  341.      */
  342.     public function updateStatusformAction(Request $request, string $ids)
  343.     {
  344.         $form = $this->createForm(updateUserSurveyStatusType::class);
  346.         $form->handleRequest($request);
  347.         if ($form->isSubmitted() && $form->isValid()) {
  348.             $ids = explode('-', $ids);
  349.             foreach ($ids as $id) {
  350.                 $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  352.                 $this->emailService->sendUserSurveyStatusChange($userSurvey);
  354.                 $userSurvey->setUserSurveyStatus($form->getData()['userSurveyStatus']);
  355.                 $userSurvey->setDateAFC($form->getData()['dateAFC']);
  356.                 $userSurvey->setResultAFC($form->getData()['resultAFC']);
  357.                 $userSurvey->setResultAFCComment($form->getData()['resultAFCComment']);
  359.                 $this->em->persist($userSurvey);
  360.             }
  362.             $this->em->flush();
  364.             $url = $this->adminUrlGenerator
  365.                 ->setController(UserSurveyCrudController::class)
  366.                 ->setAction(Action::INDEX)
  367.                 ->generateUrl();
  369.             return $this->redirect($url);
  370.         }
  372.         return $this->render('admin/update_usersurvey_status.html.twig', [
  373.             'form' => $form->createView(),
  374.             'ids' => $ids,
  375.             'type' => 'STATUS',
  376.         ]);
  377.     }
  379.     /**
  380.      * @Route("/admin/batchupdate/usersurvey/result/{ids}", name = "batch_usersurvey_result")
  381.      *
  382.      * @return RedirectResponse|Response
  383.      */
  384.     public function updateResultformAction(Request $request, string $ids)
  385.     {
  386.         $form = $this->createForm(updateUserSurveyResultType::class);
  388.         $form->handleRequest($request);
  389.         if ($form->isSubmitted() && $form->isValid()) {
  390.             $ids = explode('-', $ids);
  391.             foreach ($ids as $id) {
  392.                 $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  393.                 $userSurvey->setResultCode($form->getData()['result']);
  395.                 if ('QR' == $userSurvey->getResultCode()) {
  396.                     $resultSurvey = $this->em->getRepository(Survey::class)->findOneByCode('QUASI_RESID');
  397.                     $userSurvey->setResultSurvey($resultSurvey);
  398.                 } elseif ('RS' == $userSurvey->getResultCode()) {
  399.                     $resultSurvey = $this->em->getRepository(Survey::class)->findOneByCode('RECT_STD');
  400.                     $userSurvey->setResultSurvey($resultSurvey);
  401.                 } else {
  402.                     $userSurvey->setResultSurvey(null);
  403.                 }
  405.                 $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE');
  406.                 $userSurvey->setUserSurveyStatus($status);
  408.                 $this->em->persist($userSurvey);
  410.                 $this->emailService->sendUserSurveyStatusChange($userSurvey);
  411.             }
  413.             $this->em->flush();
  414.             $url = $this->adminUrlGenerator
  415.                 ->setController(UserSurveyCrudController::class)
  416.                 ->setAction(Action::INDEX)
  417.                 ->generateUrl();
  419.             return $this->redirect($url);
  420.         }
  422.         return $this->render('admin/update_usersurvey_status.html.twig', [
  423.             'form' => $form->createView(),
  424.             'ids' => $ids,
  425.             'type' => 'RESULT',
  426.         ]);
  427.     }
  429.     /**
  430.      * @Route("/admin/getax/download/all", name = "getax_download_all")
  431.      */
  432.     public function downloadAllGetaxFilesAction()
  433.     {
  434.         $files = scandir($_ENV['GOOGLE_DRIVE_TAX_FOLDER']);
  436.         if (count($files) > 2) {
  437.             $zip = new \ZipArchive();
  439.             // The name of the Zip documents.
  440.             $zipName = $this->getParameter('webdir') . '/uploads/files/getax_all.zip';
  442.             $zip->open($zipName, \ZipArchive::CREATE);
  444.             foreach ($files as $fileName) {
  445.                 if (!in_array($fileName, ['.', '..'])) {
  446.                     $file = $this->getParameter('webdir') . '/uploads/files/getax/tax/' . $fileName;
  447.                     $zip->addFromString(basename($file), file_get_contents($file));
  448.                 }
  449.             }
  451.             $zip->close();
  453.             $response = new Response(file_get_contents($zipName));
  454.             $response->headers->set('Content-Type', 'application/zip');
  455.             $response->headers->set('Content-Disposition', 'attachment;filename="getax_all.zip"');
  456.             $response->headers->set('Content-length', filesize($zipName));
  458.             @unlink($zipName);
  460.             return $response;
  461.         } else {
  462.             $this->addFlash('danger', 'Aucuns fichiers trouvés');
  463.             $url = $this->adminUrlGenerator
  464.                 ->setController(UserSurveyCrudController::class)
  465.                 ->setAction(Action::INDEX)
  466.                 ->generateUrl();
  468.             return $this->redirect($url);
  469.         }
  470.     }
  472.     /**
  473.      * @Route("/admin/getax/monitor", name = "getax_monitor_robot")
  474.      */
  475.     public function monitorGetaxRobotAction(Request $request)
  476.     {
  477.         if ($request->isXmlHttpRequest()) {
  478.             $url = $_ENV['LOCAL_MONITOR_PATH'];
  480.             $ch = curl_init();
  481.             curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  482.             curl_setopt($ch, CURLOPT_URL, $url);
  484.             $jsonData = curl_exec($ch);
  485.         } else {
  486.             $jsonData = ['result' => false];
  487.         }
  489.         return new JsonResponse($jsonData);
  490.     }
  492.     /**
  493.      * @Route("/count/survey", name = "count_survey")
  494.      */
  495.     public function countSurveyAction(Request $request)
  496.     {
  497.         $jsonData = ['result' => false];
  499.         if ($request->isXmlHttpRequest()) {
  500.             $userSurveysQuery = $this->em->getRepository(UserSurvey::class)
  501.                 ->createQueryBuilder('us')
  502.                 ->join('us.userSurveyStatus', 'uss')
  503.                 ->where('us.survey = :survey')
  504.                 ->andWhere('uss.code = :status')
  505.                 ->andWhere('us.isArchived = :isArchived')
  506.                 ->setParameters(['survey' => $request->request->get('survey'), 'status' => $request->request->get('status'), 'isArchived' => 0])
  507.                 ->getQuery();
  508.             $userSurveys = count(new Paginator($userSurveysQuery));
  509.             $jsonData = ['result' => $userSurveys];
  510.         }
  512.         return new JsonResponse($jsonData);
  513.     }
  515.     /**
  516.      * @Route("/count/date/survey", name = "count_survey_date")
  517.      *
  518.      * @throws Exception
  519.      */
  520.     public function countSurveyDateAction(Request $request)
  521.     {
  522.         $jsonData = ['result' => false];
  523.         if ($request->isXmlHttpRequest()) {
  524.             $dateLimits = $this->em->getRepository(UserSurvey::class)->findLast();
  525.             $dateLimits[0]->fillDateLimitArray();
  526.             $dateLimitArray = $dateLimits[0]->getDateLimitArray();
  527.             if (!empty($dateLimitArray)) {
  528.                 $keys = array_keys($dateLimitArray);
  529.                 $usRepoQueryBuilder = $this->em->getRepository(UserSurvey::class)->createQueryBuilder('entity');
  530.                 $queryBuilder = $this->userSurveyQueryService->initQueryBuilder($usRepoQueryBuilder);
  531.                 $queryBuilder = $this->userSurveyQueryService->getUserSurveyDateLimitFilterQueryBuilder($usRepoQueryBuilder, $request->get('dateLimit'));
  532.                 if (!empty($request->get('status'))) {
  533.                     $status_list = explode(',', $request->get('status'));
  534.                     $queryBuilder = $this->userSurveyQueryService->getUserSurveyStatusFilterQueryBuilder($queryBuilder, $status_list);
  535.                 }
  537.                 $userSurveys = count(new Paginator($queryBuilder->getQuery()));
  538.                 $jsonData = ['result' => $userSurveys];
  539.             }
  540.         }
  542.         return new JsonResponse($jsonData);
  543.     }
  545.     /**
  546.      * @Route(path = "/usersurvey/display/{id}", name = "usersurvey_display")
  547.      *
  548.      * @return RedirectResponse|Response
  549.      */
  550.     public function displayUserSurveyAction(Request $request, $id)
  551.     {
  552.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  554.         if (!$userSurvey) {
  555.             throw new NotFoundHttpException();
  556.         }
  558.         $userFile = $userSurvey->getUserFile();
  560.         $current_status = $userSurvey->getStatus();
  561.         $current_resultCode = $userSurvey->getResultCode();
  562.         $current_datelimit = $userSurvey->getDateLimit();
  563.         $wasPaid = $userSurvey->isPaid();
  564.         $oldPrice = $userSurvey->getPrice();
  566.         $sendMail = false;
  568.         // form pour le resultat de la simulation
  569.         $formSimulation = $this->createForm(SimulationType::class, $userSurvey);
  570.         $formSimulation->handleRequest($request);
  571.         if ($formSimulation->isSubmitted() && $formSimulation->isValid()) {
  572.             $userSurvey = $formSimulation->getData();
  574.             $statusChange = $formSimulation->get('statusChange')->getData();
  575.             $switchToPaid = $formSimulation->get('switchToPaid')->getData();
  576.             $sendMail = $formSimulation->get('sendMail')->getData();
  578.             // pour les resultats simulations
  579.             if ($current_resultCode != $userSurvey->getResultCode()) {
  580.                 $this->userSurveyService->setSurveyResult($userSurvey);
  581.             }
  583.             if ($switchToPaid) {
  584.                 $userSurvey->setPaymentStatus('payedout');
  585.             }
  587.             if ($statusChange) {
  588.                 $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE_PAYMENT_PENDING');
  589.                 if ($switchToPaid || $userSurvey->isPaid()) {
  590.                     $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE');
  591.                 }
  592.                 $userSurvey->setUserSurveyStatus($status);
  593.             }
  595.             $this->em->persist($userSurvey);
  596.             $this->em->flush();
  597.             $this->addFlash('success', 'Resulat de la simulation sauvegardé');
  598.         }
  600.         // form pour le resultat AFC
  601.         $formAFC = $this->createForm(AFCType::class, $userSurvey);
  602.         $formAFC->handleRequest($request);
  603.         if ($formAFC->isSubmitted() && $formAFC->isValid()) {
  604.             $userSurvey = $formAFC->getData();
  606.             $statusChange = $formAFC->get('statusChange')->getData();
  607.             $switchToPaid = $formAFC->get('switchToPaid')->getData();
  608.             $sendMail = $formAFC->get('sendMail')->getData();
  610.             if ($switchToPaid) {
  611.                 $userSurvey->setPaymentStatus('payedout');
  612.             }
  613.             if ($statusChange) {
  614.                 $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE_PAYMENT_PENDING');
  615.                 if ($switchToPaid || $userSurvey->isPaid()) {
  616.                     $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_POSTED');
  617.                 }
  618.                 $userSurvey->setUserSurveyStatus($userSurveyStatus);
  619.             }
  621.             $this->em->persist($userSurvey);
  622.             $this->em->flush();
  623.             $this->addFlash('success', 'Resulat AFC sauvegardé');
  624.         }
  626.         // form pour le resultat CMU
  627.         $formCMU = $this->createForm(CMUResultType::class, $userSurvey);
  628.         $formCMU->handleRequest($request);
  629.         if ($formCMU->isSubmitted() && $formCMU->isValid()) {
  630.             $userSurvey = $formCMU->getData();
  632.             $statusChange = $formCMU->get('statusChange')->getData();
  633.             $sendMail = $formCMU->get('sendMail')->getData();
  635.             $order = $userSurvey->getOrder();
  636.             if ($order) {
  637.                 // Mise à jour du prix de la prestation.
  638.                 $selectedProducts = $userSurvey->calculatePriceNew($this->userSurveyService);
  639.                 // facture
  640.                 $this->userSurveyService->generateUserSurveyBexioArticle($userSurvey, $selectedProducts);
  642.                 // Si changement de prix. On met à jour la facture (annule et replace)
  643.                 if ($oldPrice != $userSurvey->getPrice() && !in_array($userSurvey->getStatus(), ['CANCELED', 'INIT', 'ONGOING']) && !is_null($order->getBexioInvoiceId())) {
  644.                     $this->paymentService->updateInvoice($order);
  645.                 }
  646.             }
  648.             if ($statusChange) {
  649.                 if ('CORRECT' == $userSurvey->getCmuResultType()) {
  650.                     $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE');
  651.                 } else {
  652.                     $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('OFFER_PENDING');
  653.                 }
  654.                 $userSurvey->setUserSurveyStatus($userSurveyStatus);
  655.                 $this->userSurveyService->finishUserSurvey($userSurvey);
  656.             }
  658.             $this->em->persist($userSurvey);
  659.             $this->em->flush();
  660.             $this->addFlash('success', 'Resulat CMU sauvegardé');
  661.         }
  663.         // form pour le dépot CMU
  664.         $formCMUDate = $this->createForm(CMUDateType::class, $userSurvey);
  665.         $formCMUDate->handleRequest($request);
  666.         if ($formCMUDate->isSubmitted() && $formCMUDate->isValid()) {
  667.             $userSurvey = $formCMUDate->getData();
  669.             $statusChange = $formCMUDate->get('statusChange')->getData();
  670.             $switchToPaid = $formCMUDate->get('switchToPaid')->getData();
  671.             $sendMail = $formCMUDate->get('sendMail')->getData();
  673.             if ($switchToPaid) {
  674.                 $userSurvey->setPaymentStatus('payedout');
  675.             }
  676.             if ($statusChange) {
  677.                 $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_POSTED_CMU');
  678.                 $userSurvey->setUserSurveyStatus($userSurveyStatus);
  679.             }
  681.             $this->em->persist($userSurvey);
  682.             $this->em->flush();
  683.             $this->addFlash('success', 'Resulat CMU sauvegardé');
  684.         }
  686.         // form pour le dépot des rmb LPP
  687.         $formRmbLpp = $this->createForm(RmbLppDateType::class, $userSurvey);
  688.         $formRmbLpp->handleRequest($request);
  689.         if ($formRmbLpp->isSubmitted() && $formRmbLpp->isValid()) {
  690.             $userSurvey = $formRmbLpp->getData();
  692.             $statusChange = $formRmbLpp->get('statusChange')->getData();
  693.             $switchToPaid = $formRmbLpp->get('switchToPaid')->getData();
  694.             $sendMail = $formRmbLpp->get('sendMail')->getData();
  696.             if ($switchToPaid) {
  697.                 $userSurvey->setPaymentStatus('payedout');
  698.             }
  699.             if ($statusChange) {
  700.                 $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_POSTED');
  701.                 $userSurvey->setUserSurveyStatus($userSurveyStatus);
  702.             }
  704.             $this->em->persist($userSurvey);
  705.             $this->em->flush();
  706.             $this->addFlash('success', 'Date AFC sauvegardé');
  707.         }
  710.         // form pour le resultat Impot france
  711.         $formIF = $this->createForm(IFResultType::class, $userSurvey);
  712.         $formIF->handleRequest($request);
  713.         if ($formIF->isSubmitted() && $formIF->isValid()) {
  714.             $userSurvey = $formIF->getData();
  716.             $statusChange = $formIF->get('statusChange')->getData();
  717.             $switchToPaid = $formIF->get('switchToPaid')->getData();
  718.             $sendMail = $formIF->get('sendMail')->getData();
  720.             if ($switchToPaid) {
  721.                 $userSurvey->setPaymentStatus('payedout');
  722.             }
  723.             if ($statusChange) {
  724.                 $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('DONE_PAYMENT_PENDING');
  725.                 if ($switchToPaid || $userSurvey->isPaid()) {
  726.                     $userSurveyStatus = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_POSTED_FR');
  727.                 }
  728.                 $userSurvey->setUserSurveyStatus($userSurveyStatus);
  729.             }
  731.             $this->em->persist($userSurvey);
  732.             $this->em->flush();
  733.             $this->addFlash('success', 'Resulat Impot France sauvegardé');
  734.         }
  736.         // form pour modifier les infos de base (status/prix/date etc..)
  737.         $formUserSurvey = $this->createForm(updateUserSurveyType::class, $userSurvey);
  738.         $formUserSurvey->handleRequest($request);
  739.         if ($formUserSurvey->isSubmitted() && $formUserSurvey->isValid()) {
  740.             $userSurvey = $formUserSurvey->getData();
  742.             $sendMail = $formUserSurvey->get('sendMail')->getData();
  744.             if (!is_null($userSurvey->getOrder())) {
  745.                 $order = $userSurvey->getOrder();
  747.                 // Le formulaire rajoute des réductions.
  748.                 foreach ($order->getDiscounts() as $discount) {
  749.                     if (is_null($discount->getType())) {
  750.                         $discount
  751.                             ->setType('ADMIN')
  752.                             ->setNbTimesUsed(1)
  753.                             ->setNbCounted(1)
  754.                             ->setDateValid(new DateTime())
  755.                             ->setCode($this->discountService->generateCode($userSurvey->getUser(), 'ADMIN'));
  756.                     }
  757.                 }
  759.                 // Annulation de la facture. Si annulé
  760.                 if ('CANCELED' == $userSurvey->getStatus()) {
  761.                     $order = $userSurvey->getOrder();
  762.                     if (!is_null($order->getBexioInvoiceId())) {
  763.                         $this->bexioService->cancelInvoice($order->getBexioInvoiceId());
  764.                     }
  765.                 } else {
  766.                     if (!$userSurvey->isPaid()) {
  767.                         // Mise à jour du prix de la prestation.
  768.                         $selectedProducts = $userSurvey->calculatePriceNew($this->userSurveyService);
  769.                         // facture
  770.                         $this->userSurveyService->generateUserSurveyBexioArticle($userSurvey, $selectedProducts);
  772.                         // Si changement de prix. On met à jour la facture (annule et replace)
  773.                         if ($oldPrice != $userSurvey->getPrice() && !in_array($userSurvey->getStatus(), ['CANCELED', 'INIT', 'ONGOING'])) {
  774.                             $this->paymentService->updateInvoice($order);
  775.                         }
  776.                         $this->em->persist($order);
  777.                         $this->em->persist($userSurvey);
  778.                         $this->em->flush();
  779.                     }
  780.                 }
  781.             }
  783.             // annulation de la facture bexio
  784.             if ('CANCELED' == $userSurvey->getStatus()) {
  785.                 if (!is_null($userSurvey->getOrder())) {
  786.                     $order = $userSurvey->getOrder();
  787.                     if (!is_null($order->getBexioInvoiceId())) {
  788.                         $this->bexioService->cancelInvoice($order->getBexioInvoiceId());
  789.                     }
  790.                 }
  791.             }
  793.             if ($current_datelimit != $userSurvey->getDateLimit()) {
  794.                 if ($sendMail) {
  795.                     $this->emailService->sendDateLimitUpdate($userSurvey);
  796.                 }
  797.             }
  799.             $this->em->persist($userSurvey);
  800.             $this->em->flush();
  802.             $this->addFlash('success', 'Dossier mis à jour avec succès');
  803.         }
  805.         // Si paiement : génération de la facture si inexistante et on la met en payé.
  806.         if ($userSurvey->isPaid() && !$wasPaid) {
  807.             $this->paymentService->processPayment($userSurvey, $sendMail, true);
  808.             if ($sendMail) {
  809.                 $this->emailService->sendUserSurveyPaymentStatusUpdate($userSurvey);
  810.             }
  811.         }
  813.         // changement de status
  814.         if ($current_status != $userSurvey->getStatus()) {
  815.             if ($sendMail) {
  816.                 $this->emailService->sendUserSurveyStatusChange($userSurvey);
  817.             }
  819.             // si simu : on lance la generation du XML
  820.             if ('SIMULATION' == $userSurvey->getSurvey()->getCode() && 'PROCESSING' == $userSurvey->getStatus()) {
  821.                 if (!is_null($userSurvey->getUserFile()->getOwner())) {
  822.                     $xml = $this->xmlService->generateGetaxXmlFile($userSurvey);
  823.                     file_put_contents($this->getParameter('webdir') . '/uploads/files/getax/xml/' . $userSurvey->getId() . '_' . $userSurvey->getUser()->getLastname() . $userSurvey->getUser()->getName() . (date('Y') - 1) . '_' . date('d_m_y') . '.xml', $xml);
  824.                     $this->addFlash('success', 'Fichier Getax généré');
  825.                 }
  826.             }
  827.             if ($userSurvey->getUserSurveyStatus()->getCode() == 'DONE_PAYMENT_PENDING') {
  828.                 if (!$userSurvey->getOrder()) {
  829.                     $order = new Order($userSurvey->getPrice(), $userSurvey);
  830.                     $userSurvey->setOrder($order);
  831.                 }
  832.                 $order = $userSurvey->getOrder();
  834.                 $this->paymentService->adminPreparePayment($order);
  835.             }
  836.         }
  838.         $userSurveyComment = new UserSurveyComment();
  839.         $userSurveyComment->setUser($this->getUser());
  840.         $userSurveyComment->setUserSurvey($userSurvey);
  841.         $userSurveyCommentForm = $this->createForm(UserSurveyCommentType::class, $userSurveyComment);
  843.         $userSurveyCommentForm->handleRequest($request);
  844.         if ($userSurveyCommentForm->isSubmitted()) {
  845.             if ($userSurveyCommentForm->isValid()) {
  846.                 $userSurveyComment = $userSurveyCommentForm->getData();
  847.                 $this->em->persist($userSurveyComment);
  848.                 $this->em->flush();
  849.                 $this->addFlash('success', 'Commentaire ajouté');
  850.             } else {
  851.                 $this->addFlash('danger', "le commentaire n'as pas été ajouté");
  852.             }
  853.         }
  855.         $logStatusHistory = $this->logService->getStatusChangeHistoryStrings($userSurvey);
  856.         $logPaymentHistory = $this->logService->getPaymentStatusChangeHistoryStrings($userSurvey);
  857.         $logDateLimitHistory = $this->logService->getDateLimitChangeHistoryStrings($userSurvey);
  858.         $logDocumentAskHistory = $this->logService->getDocumentAskHistoryStrings($userSurvey);
  860.         /**
  861.          * Refresh des formulaires avec les nouvelles data...
  862.          */
  863.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  864.         $formSimulation = $this->createForm(SimulationType::class, $userSurvey);
  865.         $formAFC = $this->createForm(AFCType::class, $userSurvey);
  866.         $formIF = $this->createForm(IFResultType::class, $userSurvey);
  867.         $formCMU = $this->createForm(CMUResultType::class, $userSurvey);
  868.         $formCMUDate = $this->createForm(CMUDateType::class, $userSurvey);
  869.         $formRmbLpp = $this->createForm(RmbLppDateType::class, $userSurvey);
  870.         $formUserSurvey = $this->createForm(updateUserSurveyType::class, $userSurvey);
  871.         $userSurveyComment = new UserSurveyComment();
  872.         $userSurveyComment->setUser($this->getUser());
  873.         $userSurveyComment->setUserSurvey($userSurvey);
  874.         $userSurveyCommentForm = $this->createForm(UserSurveyCommentType::class, $userSurveyComment);
  876.         return $this->render('admin/display_user_survey/display_usersurvey.html.twig', [
  877.             'userSurvey' => $userSurvey,
  878.             'logStatusHistory' => $logStatusHistory,
  879.             'logPaymentHistory' => $logPaymentHistory,
  880.             'logDateLimitHistory' => $logDateLimitHistory,
  881.             'logDocumentAskHistory' => $logDocumentAskHistory,
  882.             'userFile' => $userFile,
  883.             'survey' => $userSurvey->getSurvey(),
  884.             'surveyMode' => $userSurvey->getSurveyModeObject(),
  885.             'formUserSurvey' => $formUserSurvey->createView(),
  886.             'formSimulation' => $formSimulation->createView(),
  887.             'formCMU' => $formCMU->createView(),
  888.             'formCMUDate' => $formCMUDate->createView(),
  889.             'formRmbLpp' => $formRmbLpp->createView(),
  890.             'formAFC' => $formAFC->createView(),
  891.             'formIF' => $formIF->createView(),
  892.             'userSurveyCommentForm' => $userSurveyCommentForm->createView(),
  893.             'user' => $userSurvey->getUser(),
  894.             'emails' => $userSurvey->getEmails()
  895.         ]);
  896.     }
  898.     /**
  899.      * @Route("/ajax/display/usersurvey/{userSurveyId}",name="ajax_display_usersurvey")
  900.      */
  901.     public function ajaxDisplayUserSurvey($userSurveyId): JsonResponse
  902.     {
  903.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  904.         if (!$userSurvey) {
  905.             throw new NotFoundHttpException();
  906.         }
  908.         $userFile = $userSurvey->getUserFile();
  910.         return new JsonResponse($this->renderView('admin/display_user_survey/resume/resume.html.twig', [
  911.             'userSurvey' => $userSurvey,
  912.             'userFile' => $userFile,
  913.             'survey' => $userSurvey->getSurvey(),
  914.             'surveyMode' => $userSurvey->getSurveyModeObject(),
  915.             'user' => $userSurvey->getUser(),
  916.         ]));
  917.     }
  919.     /**
  920.      * @Route(path = "/usersurvey/access", name = "usersurvey_access")
  921.      *
  922.      * @return RedirectResponse|Response
  923.      */
  924.     public function accessUserSurveyAction(Request $request)
  925.     {
  926.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($request->query->get('id'));
  928.         if (!$userSurvey) {
  929.             throw new NotFoundHttpException();
  930.         }
  932.         $user = $userSurvey->getUser();
  934.         // if (count($this->get('security.token_storage')->getToken()->getRoles()) > 2) {
  935.         if ($this->isGranted('IS_IMPERSONATOR')) {
  936.             return $this->redirectToRoute('admin_usersurvey_reaccess', [
  937.                 'id' => $userSurvey->getId(),
  938.                 '_switch_user' => '_exit',
  939.             ]);
  940.         }
  942.         return $this->redirectToRoute('usersurvey_process', [
  943.             'userSurveyId' => $userSurvey->getId(),
  944.             '_switch_user' => $user->getUserIdentifier(),
  945.         ]);
  946.     }
  948.     /**
  949.      * @Route("/usersurvey/reaccess/{id}", name = "usersurvey_reaccess")
  950.      *
  951.      * @return RedirectResponse|Response
  952.      */
  953.     public function reAccessUserSurveyAction($id)
  954.     {
  955.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($id);
  957.         if (!$userSurvey) {
  958.             throw new NotFoundHttpException();
  959.         }
  961.         $user = $userSurvey->getUser();
  963.         return $this->redirectToRoute('usersurvey_process', [
  964.             'userSurveyId' => $userSurvey->getId(),
  965.             '_switch_user' => $user->getUserIdentifier(),
  966.         ]);
  967.     }
  969.     /**
  970.      * @Route("/usersurvey/updateStatus", name = "change_statut_color")
  971.      */
  972.     public function changeStatutColors(Request $request)
  973.     {
  974.         $jsonData = ['result' => false];
  976.         if ($request->isXmlHttpRequest()) {
  977.             $statusColor = $this->em->getRepository(AdminStatus::class)->find($request->request->get('statut'));
  978.             $survey = $this->em->getRepository(UserSurvey::class)->find($request->request->get('survey'));
  979.             $survey->setAdminStatus($statusColor);
  980.             $this->em->flush();
  981.             $jsonData = ['result' => $statusColor->getColor()];
  982.         }
  984.         return new JsonResponse($jsonData);
  985.     }
  987.     /**
  988.      * @Route("/usersurvey/deleteDocument/{idDocument}", name = "delete_document")
  989.      * @Route("/usersurvey/deleteDocumentArchived/{idDocument}", name = "delete_document_archived")
  990.      * @Route("/usersurvey/restoreDocumentArchived/{idDocumentToRestore}", name = "restore_document_archived")
  991.      */
  992.     public function deleteDocument($idDocument = null, $idDocumentToRestore = null): JsonResponse
  993.     {
  994.         if ($idDocument) {
  995.             $userFileDocument = $this->em->getRepository(UserFileDocument::class)->find((int)$idDocument);
  997.             if ($userFileDocument) {
  998.                 $userFileDocument->setIsArchived(true);
  999.                 $userFileDocument->setValidState(null);
  1000.                 $userFileDocument->setSavedDocumentUser(null);
  1001.                 $this->em->persist($userFileDocument);
  1002.                 $this->em->flush();
  1004.                 return new JsonResponse(true);
  1005.             }
  1006.         }
  1008.         if ($idDocumentToRestore) {
  1009.             $userFileDocument = $this->em->getRepository(UserFileDocument::class)->find((int)$idDocumentToRestore);
  1011.             if ($userFileDocument) {
  1012.                 $userFileDocument->setIsArchived(false);
  1013.                 $userFileDocument->setValidState(null);
  1014.                 $userFileDocument->setSavedDocumentUser(null);
  1015.                 $this->em->persist($userFileDocument);
  1016.                 $this->em->flush();
  1018.                 return new JsonResponse(true);
  1019.             }
  1020.         }
  1022.         return new JsonResponse(false);
  1023.     }
  1025.     /**
  1026.      * @Route("/ajax/validDoc/getArchivedDocs", name = "ajax_get_archived_documents")
  1027.      */
  1028.     public function getArchiveDocuments(Request $request): JsonResponse
  1029.     {
  1030.         $finalData = [];
  1032.         $userFileId = $request->get('userFileId');
  1033.         $userSurveyId = $request->get('userSurveyId');
  1035.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1037.         /**
  1038.          * @var UserFileDocument $ufda
  1039.          */
  1040.         foreach ($userFile->getArchivedDocuments() as $ufda) {
  1041.             $id = 0;
  1042.             if ($ufda->getDocumentTag()) {
  1043.                 $id = $ufda->getDocumentTag()->getId();
  1044.             }
  1045.             $finalData[$id]['nameDocGroup'] = $ufda->getFullName();
  1046.             $finalData[$id]['userFileDocument'][] = [
  1047.                 'id' => $ufda->getId(),
  1048.                 'name' => $ufda->getFileName(),
  1049.                 'validState' => $ufda->getValidState(),
  1050.                 'comment' => $ufda->getValidComment(),
  1051.                 'path' => $request->getUriForPath('/uploads/files/documents/' . $userSurveyId . '/' . $ufda->getFileName()),
  1052.                 'deletePathDoc' => $this->generateUrl('admin_delete_document_archived', ['idDocument' => $ufda->getId()]),
  1053.                 'restoreDoc' => $this->generateUrl('admin_restore_document_archived', ['idDocumentToRestore' => $ufda->getId()]),
  1054.                 'archivedPathDoc' => $this->generateUrl('admin_delete_document', ['idDocument' => $ufda->getId()]),
  1055.             ];
  1056.         }
  1058.         return new JsonResponse(['finalData' => $finalData, 'error' => null]);
  1059.     }
  1061.     /**
  1062.      * @Route("/ajax/validDoc/valid", name = "ajax_valid_doc")
  1063.      */
  1064.     public function validDocument(Request $request): JsonResponse
  1065.     {
  1066.         $userFileDocumentId = $request->get('userFileDocumentId');
  1067.         $comment = $request->get('comment');
  1068.         $validation = (bool)$request->get('validation');
  1070.         $userFileDocument = $this->changeDocumentValidationStateId($userFileDocumentId, $validation, $comment);
  1072.         $result = false;
  1073.         if ($userFileDocument->getValidState() === $validation) {
  1074.             $result = true;
  1075.         }
  1077.         return new JsonResponse(['result' => $result]);
  1078.     }
  1080.     private function changeDocumentValidationStateId($userFileDocumentId, $state, $comment = '')
  1081.     {
  1082.         $userFileDocument = $this->em->getRepository(UserFileDocument::class)->find((int)$userFileDocumentId);
  1083.         $userFileDocument = $this->changeDocumentValidationState($userFileDocument, $state, $comment);
  1085.         return $userFileDocument;
  1086.     }
  1088.     private function changeDocumentValidationState(UserFileDocument $userFileDocument, $state, $comment = '')
  1089.     {
  1090.         $userFileDocument->setValidState($state);
  1091.         if ($state) {
  1092.             $userFileDocument->setNotDeductible(false);
  1093.         }
  1094.         $userFileDocument->setValidComment($comment);
  1095.         $this->em->persist($userFileDocument);
  1096.         $this->em->flush();
  1098.         return $userFileDocument;
  1099.     }
  1101.     /**
  1102.      * @Route("/document/summary/{userFileId}/{userSurveyId}", name = "document_summary")
  1103.      */
  1104.     public function documentSummary(Request $request, $userFileId, $userSurveyId)
  1105.     {
  1106.         // liste des docs, voir les validé, invalidé, archvé
  1107.         $userFile = $this->em->getRepository(UserFile::class)->find((int)$userFileId);
  1108.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1111.         $documents = [
  1112.             'validated' => $userFile->getValidatedDocuments(),
  1113.             'unvalidated' => $userFile->getUnvalidatedDocuments(),
  1114.             'not_deductible' => $userFile->getNotDeductibleDocuments(),
  1115.             'not_reviewed' => $userFile->getNotReviewedDocuments(),
  1116.             'missing' => $this->userSurveyService->getMissingFiles($userSurvey, $userFile, true),
  1117.             'missing_send_to_client' => $userFile->getUserFileMissingFilesToDocument(),
  1118.             'archived' => $userFile->getArchivedDocuments(),
  1119.         ];
  1121.         return $this->render('admin/userFileDocument/document_summary.html.twig', [
  1122.             'userSurvey' => $userSurvey,
  1123.             'userFile' => $userFile,
  1124.             'documents' => $documents,
  1125.         ]);
  1126.     }
  1128.     /**
  1129.      * @Route("/userfile/validate/{userFileId}/{userSurveyId}", name = "validate_userfile")
  1130.      */
  1131.     public function validateUserFile($userFileId, $userSurveyId)
  1132.     {
  1133.         // check for missing documents/ not reviewed document
  1134.         // if no missing and all document validated
  1135.         // valid the userfile/userSurvey
  1136.         // send the mail if needed
  1138.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1139.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1140.         $isValid = $userFile->isValid();
  1141.         $original_status = $userSurvey->getStatus();
  1142.         $sendMail = true;
  1144.         if (!in_array($original_status, $this->autorizedStatusForComplete)) {
  1145.             $this->addFlash('danger', "Le dossier n'est pas dans le bon status. ");
  1147.             return $this->redirectToRoute('admin_document_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1148.         }
  1150.         if (true === $isValid['valid']) {
  1151.             if ('SIMULATION' == $userSurvey->getSurvey()->getCode()) {
  1152.                 $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING');
  1153.                 $userSurvey->setUserSurveyStatus($status);
  1154.                 // si simu : on lance la generation du XML
  1155.                 if (!is_null($userSurvey->getUserFile()->getOwner())) {
  1156.                     $xml = $this->xmlService->generateGetaxXmlFile($userSurvey);
  1157.                     file_put_contents($this->getParameter('webdir') . '/uploads/files/getax/xml/' . $userSurvey->getId() . '_' . $userSurvey->getUser()->getLastname() . $userSurvey->getUser()->getName() . (date('Y') - 1) . '_' . date('d_m_y') . '.xml', $xml);
  1158.                     $this->addFlash('success', 'Fichier Getax généré');
  1159.                 }
  1160.             } elseif ('REMBOURSEMENT_LPP' == $userSurvey->getSurvey()->getCode() && !$userFile->hasValidatedDocumentsByCode("DOC_IMP_FR")) {
  1161.                 $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FR_WAIT');
  1162.                 $userSurvey->setUserSurveyStatus($status);
  1164.                 $document = $this->em->getRepository(Document::class)->findOneBy(['code' => "DOC_IMP_FR"]);
  1166.                 $documentTag = new DocumentTypeTag();
  1167.                 $documentTag->setUserFile($userFile);
  1168.                 $documentTag->setDocument($document);
  1169.                 $this->em->persist($documentTag);
  1171.                 $userFileMissingFile = new UserFileMissingFiles();
  1172.                 $userFileMissingFile
  1173.                     ->addTag($documentTag)
  1174.                     ->setUserFile($userFile);
  1175.                 $this->em->persist($userFileMissingFile);
  1177.             } else {
  1178.                 $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_COMPLETED');
  1179.                 $userSurvey->setUserSurveyStatus($status);
  1180.             }
  1181.             if ($original_status == $userSurvey->getStatus()) {
  1182.                 $sendMail = false;
  1183.             }
  1185.             $this->em->persist($userSurvey);
  1186.             $this->em->flush();
  1188.             // Mail to the customer only if the status has change
  1189.             if ($sendMail) {
  1190.                 $this->emailService->sendUserSurveyStatusChange($userSurvey);
  1191.             }
  1193.             return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  1194.         }
  1196.         return $this->redirectToRoute('admin_document_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1197.     }
  1199.     /**
  1200.      * @Route("/userfile/sendMissingFiles/{userFileId}/{userSurveyId}", name = "send_missing_files")
  1201.      */
  1202.     public function sendMissingFile(Request $request, $userFileId, $userSurveyId)
  1203.     {
  1204.         // Create userMissingFiles based on empty document groups and invalid files
  1205.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1206.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1207.         $sendMail = true;
  1209.         if (!$userFile) {
  1210.             throw new NotFoundHttpException();
  1211.         }
  1212.         if (!$userSurvey) {
  1213.             throw new NotFoundHttpException();
  1214.         }
  1216.         $original_status = $userSurvey->getStatus();
  1217.         if (!in_array($original_status, $this->autorizedStatusForIncomplete)) {
  1218.             $this->addFlash('danger', "Le dossier n'est pas dans le bon status.");
  1220.             return $this->redirectToRoute('admin_document_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1221.         }
  1223.         // Documents obligatoires manquant
  1224.         // 1/ créé des userFileDocument avec les Tags du document Manquant
  1225.         $content = $request->getContent();
  1226.         if (!empty($content)) {
  1227.             $data = json_decode($content, true);
  1228.             foreach ($data as $ids) {
  1229.                 if (!is_null($ids)) {
  1230.                     $idTable = explode(',', $ids);
  1231.                     if (!$userFile->hasAlreadyAMissingFiles($idTable)) {
  1232.                         $userFileMissingFile = new UserFileMissingFiles();
  1233.                         $userFileMissingFile->setUserFile($userFile);
  1234.                         foreach ($idTable as $id) {
  1235.                             $tag = $this->em->getRepository(Tag::class)->find($id);
  1236.                             if ($tag) {
  1237.                                 $userFileMissingFile->addTag($tag);
  1238.                             }
  1239.                         }
  1240.                         $this->em->persist($userFileMissingFile);
  1241.                     }
  1242.                 }
  1243.             }
  1244.         }
  1246.         // Documents invalides
  1247.         $invalidFiles = $userFile->getUnvalidatedDocuments();
  1248.         foreach ($invalidFiles as $userFileDocument) {
  1249.             $tagIds = $userFileDocument->getTagIds();
  1250.             if (!$userFile->hasAlreadyAMissingFiles($tagIds)) {
  1251.                 $userFileMissingFile = new UserFileMissingFiles($userFileDocument);
  1252.                 $this->em->persist($userFileMissingFile);
  1253.             }
  1254.         }
  1256.         // pass the usersurvey into missing files
  1257.         $status = $this->em->getRepository(UserSurveyStatus::class)->findOneByCode('PROCESSING_FILES_MISSING');
  1258.         $userSurvey->setUserSurveyStatus($status);
  1260.         $this->em->persist($userFile);
  1261.         $this->em->persist($userSurvey);
  1262.         $this->em->flush();
  1264.         // send mail
  1265.         if ($original_status == $userSurvey->getStatus()) {
  1266.             $sendMail = false;
  1267.         }
  1268.         if ($sendMail) {
  1269.             $this->emailService->sendUserSurveyStatusChange($userSurvey);
  1270.             $this->addFlash('success', 'Fichiers mis à jour et client avertis par e-mail.');
  1271.         }
  1273.         // Redirect to document summary
  1274.         return $this->redirectToRoute('admin_document_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1275.     }
  1277.     /**
  1278.      * @Route("/delete/sent/missing/files/{userFileId}/{userSurveyId}", name="delete_sent_missing_files")
  1279.      */
  1280.     public function deleteSentMissingFiles(Request $request, $userFileId, $userSurveyId)
  1281.     {
  1282.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1283.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1285.         if (!$userFile) {
  1286.             throw new NotFoundHttpException();
  1287.         }
  1288.         if (!$userSurvey) {
  1289.             throw new NotFoundHttpException();
  1290.         }
  1291.         $content = $request->getContent();
  1292.         if (!empty($content)) {
  1293.             $data = json_decode($content, true);
  1294.             if (!empty($data)) {
  1295.                 foreach ($data as $userFileMissingFileId) {
  1296.                     $userFileMissingFile = $this->em->getRepository(UserFileMissingFiles::class)->find($userFileMissingFileId);
  1297.                     if ($userFileMissingFile) {
  1298.                         $this->em->remove($userFileMissingFile);
  1299.                     }
  1300.                 }
  1301.                 $this->em->flush();
  1302.             }
  1303.         }
  1305.         return $this->redirectToRoute('admin_document_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1306.     }
  1308.     /**
  1309.      * @Route("/ajax/createMissingFile/{userFileId}/{userSurveyId}", name = "ajax_create_missing_file")
  1310.      */
  1311.     public function ajaxCreateMissingFile(Request $request, $userFileId, $userSurveyId)
  1312.     {
  1313.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1314.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1316.         if (!$userSurvey || !$userFile) {
  1317.             throw new NotFoundHttpException();
  1318.         }
  1320.         $form = $this->createForm(
  1321.             UserFileDocumentAskType::class, null,
  1322.             [
  1323.                 'userFile' => $userFile,
  1324.                 'action' => $this->generateUrl(
  1325.                     'admin_ajax_create_missing_file',
  1326.                     [
  1327.                         'userSurveyId' => $userSurveyId,
  1328.                         'userFileId' => $userFileId
  1329.                     ]
  1330.                 ),
  1331.             ]
  1332.         );
  1334.         $form->handleRequest($request);
  1335.         if ($form->isSubmitted()) {
  1336.             if ($form->isValid()) {
  1337.                 $entityTypeTags = $form->get('entityTypeTags')->getData();
  1338.                 $documentId = $form->get('document')->getData();
  1340.                 $document = $this->em->getRepository(Document::class)->find($documentId);
  1342.                 if ($userFile->hasTag($document)) {
  1343.                     $documentTag = $userFile->getTag($document);
  1344.                 } else {
  1345.                     $documentTag = new DocumentTypeTag();
  1346.                     $documentTag->setUserFile($userFile)
  1347.                         ->setDocument($document);
  1348.                     $this->em->persist($documentTag);
  1349.                 }
  1351.                 if (!empty($entityTypeTags)) {
  1352.                     foreach (explode(',', $entityTypeTags) as $entityTypeTagId) {
  1353.                         $entityTypeTag = $this->em->getRepository(EntityTypeTag::class)->find($entityTypeTagId);
  1354.                         if (!is_null($entityTypeTag)) {
  1355.                             $userFileMissingFile = new UserFileMissingFiles();
  1356.                             $userFileMissingFile
  1357.                                 ->addTag($documentTag)
  1358.                                 ->addTag($entityTypeTag)
  1359.                                 ->setUserFile($userFile);
  1360.                             $this->em->persist($userFileMissingFile);
  1361.                         } else {
  1362.                             throw new Exception('Erreur lors de la création de la demande de document. Entitée non trouvée');
  1363.                         }
  1364.                     }
  1365.                 } else {
  1366.                     $userFileMissingFile = new UserFileMissingFiles();
  1367.                     $userFileMissingFile
  1368.                         ->addTag($documentTag)
  1369.                         ->setUserFile($userFile);
  1370.                     $this->em->persist($userFileMissingFile);
  1371.                 }
  1373.                 $this->em->flush();
  1374.                 $this->addFlash('success', 'Demande sauvegardée');
  1375.             } else {
  1376.                 $this->addFlash('danger', "Erreur lors de la création de la demande de document");
  1377.             }
  1379.             $source = $request->get('source_url');
  1381.             return $this->redirect($source);
  1382.         }
  1385.         return new JsonResponse(
  1386.             $this->renderView('admin/modals/modal_create_edit_comment.html.twig', [
  1387.                 'userSurveyCommentForm' => $form->createView()
  1388.             ]));
  1390.     }
  1392.     /**
  1393.      * @Route("/ajax/check/userFileStatus/{userFileId}/{userSurveyId}", name = "ajax_check_userfile_status")
  1394.      *
  1395.      * @return JsonResponse
  1396.      */
  1397.     public function jsonCheckStatus(Request $request, $userFileId, $userSurveyId)
  1398.     {
  1399.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1400.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1402.         if (!$userSurvey) {
  1403.             throw new NotFoundHttpException();
  1404.         }
  1406.         if (!$userFile) {
  1407.             throw new NotFoundHttpException();
  1408.         }
  1410.         $isValid = $userFile->isValid();
  1411.         if (!in_array($userSurvey->getStatus(), $this->autorizedStatusForComplete)) {
  1412.             $isValid['valid'] = false;
  1413.             $isValid['msg'] = 'Impossible de valider le dossier : le status doit être en "Dossier receptionné" ou "Documents manquants envoyé"';
  1414.         }
  1416.         return new JsonResponse($isValid);
  1417.     }
  1419.     /**
  1420.      * @Route("/download/getax/files/old/{userFileId}/{userSurveyId}", name = "download_getax_files_old")
  1421.      *
  1422.      * @return Response
  1423.      */
  1424.     public function downloadGetaxFilesOld(Request $request, $userFileId, $userSurveyId)
  1425.     {
  1426.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1427.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1429.         if (!$userSurvey) {
  1430.             throw new NotFoundHttpException();
  1431.         }
  1433.         if (!$userFile) {
  1434.             throw new NotFoundHttpException();
  1435.         }
  1437.         $userFileDocuments = $userFile->getUserFileDocumentsSorted();
  1438.         if (!empty($userFileDocuments)) {
  1439.             $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/';
  1440.             $valid_file_count = 0;
  1441.             foreach ($userFileDocuments as $files_group) {
  1442.                 foreach ($files_group as $files) {
  1443.                     foreach ($files as $filename) {
  1444.                         if (!file_exists($path . $filename)) {
  1445.                             $this->addFlash('danger', 'Fichier Introuvable : ' . $filename);
  1447.                             return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1448.                         }
  1449.                         $path_parts = pathinfo($filename);
  1450.                         if ('pdf' !== strtolower($path_parts['extension'])) {
  1451.                             $this->addFlash('danger', 'Fichier non PDF : ' . $filename);
  1453.                             return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1454.                         }
  1455.                         ++$valid_file_count;
  1456.                     }
  1457.                 }
  1458.             }
  1459.             if ($valid_file_count > 0) {
  1460.                 $outputName = $this->pdfService->clean((!$this->getUser() instanceof User ? 'undefined User' : strtoupper((string)$userSurvey->getUser()->getLastname()) . '-' . ucfirst((string)$userSurvey->getUser()->getName())) . '-Getax' . date('Y', strtotime('-1 year')));
  1461.                 $zip = new \ZipArchive();
  1463.                 // The name of the Zip documents.
  1464.                 $zipName = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/' . $outputName . '.zip';
  1466.                 $zip->open($zipName, \ZipArchive::CREATE);
  1467.                 foreach ($userFileDocuments as $entity => $files_group) {
  1468.                     foreach ($files_group as $order => $files) {
  1469.                         foreach ($files as $key => $filename) {
  1470.                             $file = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/' . $filename;
  1471.                             $output_name = $entity . '.' . $order . '.' . $key . '.' . $filename;
  1472.                             $zip->addFile($file, basename($output_name));
  1473.                         }
  1474.                     }
  1475.                 }
  1477.                 $zip->close();
  1479.                 $response = new Response(file_get_contents($zipName));
  1480.                 $response->headers->set('Content-Type', 'application/zip');
  1481.                 $response->headers->set('Content-Disposition', 'attachment;filename="' . $outputName . '.zip"');
  1482.                 $response->headers->set('Content-length', filesize($zipName));
  1484.                 @unlink($zipName);
  1486.                 return $response;
  1487.             } else {
  1488.                 $this->addFlash('danger', 'Aucun fichier trouvé pour cette prestation.');
  1490.                 return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1491.             }
  1492.         } else {
  1493.             $this->addFlash('danger', 'Aucun fichier à télécharger pour cette prestation.');
  1494.             $url = $this->adminUrlGenerator
  1495.                 ->setController(UserSurveyCrudController::class)
  1496.                 ->setAction(Action::INDEX)
  1497.                 ->generateUrl();
  1499.             return $this->redirect($url);
  1500.         }
  1501.     }
  1503.     /**
  1504.      * @Route("/download/getax/files/{userFileId}/{userSurveyId}", name = "download_getax_files")
  1505.      *
  1506.      * @return Response
  1507.      */
  1508.     public function downloadGetaxFiles(Request $request, $userFileId, $userSurveyId)
  1509.     {
  1510.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1511.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1513.         if (!$userSurvey) {
  1514.             throw new NotFoundHttpException();
  1515.         }
  1517.         if (!$userFile) {
  1518.             throw new NotFoundHttpException();
  1519.         }
  1521.         $userFileDocuments = $userFile->getValidatedDocuments();
  1522.         if (!$userFileDocuments->isEmpty()) {
  1523.             $files_to_merge = [];
  1524.             $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/';
  1525.             foreach ($userFileDocuments as $userFileDocument) {
  1526.                 $filename = $userFileDocument->getFileName();
  1527.                 if (!file_exists($path . $filename)) {
  1528.                     $this->addFlash('danger', 'Fichier Introuvable : ' . $filename);
  1530.                     return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1531.                 }
  1532.                 $path_parts = pathinfo($filename);
  1533.                 if ('pdf' !== strtolower($path_parts['extension'])) {
  1534.                     $this->addFlash('danger', 'Fichier non PDF : ' . $filename);
  1536.                     return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1537.                 }
  1538.                 if ($userFileDocument->hasDocumentTagByCode('CODE_DECLA')) {
  1539.                     continue;
  1540.                 }
  1541.                 $files_to_merge[] = $filename;
  1542.             }
  1543.             if (!empty($files_to_merge)) {
  1544.                 $mergedFile = $this->pdfService->merge($path, $files_to_merge);
  1545.                 if (true === $mergedFile['result']) {
  1546.                     $outputName = $this->pdfService->clean((!$this->getUser() instanceof User ? 'undefined User' : strtoupper((string)$userSurvey->getUser()->getLastname()) . '-' . ucfirst((string)$userSurvey->getUser()->getName())) . '-Getax' . date('Y', strtotime('-1 year')));
  1547.                     $zip = new \ZipArchive();
  1548.                     $zipName = $this->getParameter('webdir') . '/uploads/files/' . $outputName . '.zip';
  1549.                     $zip->open($zipName, \ZipArchive::CREATE);
  1550.                     $zip->addFile($path . $mergedFile['outputFileName'], $outputName . '.pdf');
  1551.                     $zip->close();
  1553.                     $response = new Response(file_get_contents($zipName));
  1554.                     $response->headers->set('Content-Type', 'application/zip');
  1555.                     $response->headers->set('Content-Disposition', 'attachment;filename="' . $outputName . '.zip"');
  1556.                     $response->headers->set('Content-length', filesize($zipName));
  1558.                     @unlink($zipName);
  1560.                     return $response;
  1561.                 } else {
  1562.                     $this->addFlash('danger', "Problème lors de l'appel a ILovePDF : " . $mergedFile['msg']);
  1564.                     return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1565.                 }
  1566.             } else {
  1567.                 $this->addFlash('danger', 'Aucun fichier trouvé pour cette prestation.');
  1569.                 return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1570.             }
  1571.         } else {
  1572.             $this->addFlash('danger', 'Aucun fichier à télécharger pour cette prestation.');
  1574.             return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1575.         }
  1576.     }
  1578.     /**
  1579.      * @Route("/download/getax/files/separated/{userFileId}/{userSurveyId}", name = "download_getax_files_separated")
  1580.      *
  1581.      * @return Response
  1582.      */
  1583.     public function downloadGetaxFilesSeparated(Request $request, $userFileId, $userSurveyId)
  1584.     {
  1585.         $userFile = $this->em->getRepository(UserFile::class)->find($userFileId);
  1586.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1588.         if (!$userSurvey) {
  1589.             throw new NotFoundHttpException();
  1590.         }
  1592.         if (!$userFile) {
  1593.             throw new NotFoundHttpException();
  1594.         }
  1596.         $userFileDocuments = $userFile->getValidatedDocuments();
  1597.         if (!$userFileDocuments->isEmpty()) {
  1598.             $files_to_merge = [];
  1599.             $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/';
  1600.             foreach ($userFileDocuments as $userFileDocument) {
  1601.                 $filename = $userFileDocument->getFileName();
  1602.                 if (!file_exists($path . $filename)) {
  1603.                     $this->addFlash('danger', 'Fichier Introuvable : ' . $filename);
  1605.                     return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1606.                 }
  1607.                 $path_parts = pathinfo($filename);
  1608.                 if ('pdf' !== strtolower($path_parts['extension'])) {
  1609.                     $this->addFlash('danger', 'Fichier non PDF : ' . $filename);
  1611.                     return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1612.                 }
  1613.                 if ($userFileDocument->hasDocumentTagByCode('CODE_DECLA')) {
  1614.                     continue;
  1615.                 }
  1616.                 $files_to_merge[] = $filename;
  1617.             }
  1618.             if (!empty($files_to_merge)) {
  1619.                 $outputName = $this->pdfService->clean((!$this->getUser() instanceof User ? 'undefined User' : strtoupper((string)$userSurvey->getUser()->getLastname()) . '-' . ucfirst((string)$userSurvey->getUser()->getName())) . '-Getax' . date('Y', strtotime('-1 year')));
  1620.                 $zip = new \ZipArchive();
  1621.                 $zipName = $this->getParameter('webdir') . '/uploads/files/' . $outputName . '.zip';
  1622.                 $zip->open($zipName, \ZipArchive::CREATE);
  1623.                 foreach ($files_to_merge as $i => $mergedFile) {
  1624.                     $zip->addFile($path . $mergedFile, $i . '.' . $mergedFile);
  1625.                 }
  1626.                 $zip->close();
  1628.                 $response = new Response(file_get_contents($zipName));
  1629.                 $response->headers->set('Content-Type', 'application/zip');
  1630.                 $response->headers->set('Content-Disposition', 'attachment;filename="' . $outputName . '.zip"');
  1631.                 $response->headers->set('Content-length', filesize($zipName));
  1633.                 @unlink($zipName);
  1635.                 return $response;
  1636.             } else {
  1637.                 $this->addFlash('danger', 'Aucun fichier trouvé pour cette prestation.');
  1639.                 return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1640.             }
  1641.         } else {
  1642.             $this->addFlash('danger', 'Aucun fichier à télécharger pour cette prestation.');
  1644.             return $this->redirectToRoute('admin_getax_informations_summary', ['userSurveyId' => $userSurveyId, 'userFileId' => $userFileId]);
  1645.         }
  1646.     }
  1648.     /**
  1649.      * @Route("/ajax/keep/pdf/pages/{userFileDocumentId}/{userSurveyId}", name = "ajax_keep_pdf_pages")
  1650.      *
  1651.      * @return Response
  1652.      */
  1653.     public function ajaxKeepPDFPages(Request $request, $userFileDocumentId, $userSurveyId)
  1654.     {
  1655.         $hasError = false;
  1656.         // trying to get the userfiledocument
  1657.         $userFileDocument = $this->em->getRepository(UserFileDocument::class)->find($userFileDocumentId);
  1658.         if (!$userFileDocument) {
  1659.             return new JsonResponse(['result' => false, 'msg' => 'Mauvais id']);
  1660.         }
  1662.         // fichier
  1663.         $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurveyId . '/';
  1664.         $filename = $userFileDocument->getFilename();
  1665.         if (!file_exists($path . $filename)) {
  1666.             return new JsonResponse(['result' => false, 'msg' => 'Fichier non trouvé']);
  1667.         }
  1669.         // getting the page count
  1670.         try {
  1671.             $count = $this->pdfService->countPDFPages($path . $filename);
  1672.         } catch (\Exception $e) {
  1673.             return new JsonResponse(['result' => false, 'msg' => $e->getMessage()]);
  1674.         }
  1675.         $pageForm = $this->createPdfPageForm(
  1676.             $this->generateUrl('admin_ajax_keep_pdf_pages', ['userFileDocumentId' => $userFileDocumentId, 'userSurveyId' => $userSurveyId]),
  1677.             $count
  1678.         );
  1680.         // handle form then redirect to base_url
  1681.         $pageForm->handleRequest($request);
  1682.         if ($pageForm->isSubmitted()) {
  1683.             $formData = $pageForm->getData();
  1684.             $source = $request->get('source_url');
  1685.             if ($pageForm->isValid()) {
  1686.                 // getting form data
  1687.                 $formData = $pageForm->getData();
  1688.                 $pages = [];
  1689.                 foreach ($formData as $page => $data) {
  1690.                     if (true === $data) {
  1691.                         $pages[] = (int)str_replace('page', '', $page);
  1692.                     }
  1693.                 }
  1694.                 if (!empty($pages)) {
  1695.                     $result = $this->pdfService->keepPages($path, $filename, $pages);
  1696.                     if (true === $result['result']) {
  1697.                         $newUfd = clone $userFileDocument;
  1698.                         $newUfd->setFilename($result['outputFileName']);
  1699.                         $newUfd->setIsSlice(true);
  1700.                         $userFileDocument->setIsArchived(true);
  1701.                         foreach ($userFileDocument->getTags() as $tag) {
  1702.                             $newUfd->addTag($tag);
  1703.                         }
  1705.                         $this->em->persist($userFileDocument);
  1706.                         $this->em->persist($newUfd);
  1707.                         $this->em->flush();
  1709.                         if (str_contains($source, $userFileDocument->getId())) {
  1710.                             $source = str_replace($userFileDocument->getId(), $newUfd->getId(), $source);
  1711.                         }
  1712.                     } else {
  1713.                         $this->addFlash('danger', "Problème lors de l'appel a ILovePDF : " . $result['msg']);
  1714.                     }
  1715.                 }
  1716.             } else {
  1717.                 $this->addFlash('danger', "Le formulaire n'est pas valide : " . $pageForm->getErrors());
  1718.             }
  1720.             return $this->redirect($source);
  1721.         }
  1723.         return new JsonResponse($this->renderView(
  1724.             'admin/userFileDocument/modal_delete_pdf_pages.html.twig',
  1725.             [
  1726.                 'form' => $pageForm->createView(),
  1727.                 'hasError' => $hasError,
  1728.                 'pageCount' => $count,
  1729.             ]
  1730.         ));
  1731.     }
  1733.     private function createPdfPageForm($action, $count)
  1734.     {
  1735.         // create form
  1736.         $pageForm = $this->createFormBuilder(null, [
  1737.             'action' => $action,
  1738.             'attr' => [
  1739.                 'class' => 'form-inline',
  1740.             ],
  1741.         ]);
  1742.         foreach (range(1, $count) as $i) {
  1743.             $pageForm->add('page' . $i, CheckboxType::class, [
  1744.                 'required' => false,
  1745.                 'data' => true,
  1746.                 'attr' => [
  1747.                     'class' => 'form-inline check-this ms-0',
  1748.                 ],
  1749.                 'label_attr' => [
  1750.                     'class' => 'checkbox-inline',
  1751.                 ],
  1752.                 'row_attr' => [
  1753.                     'class' => 'col-4 ps-0',
  1754.                 ],
  1755.             ]);
  1756.         }
  1758.         $pageForm->add('submit', SubmitType::class, [
  1759.             'label' => 'Garder ces pages',
  1760.             'attr' => [
  1761.                 'class' => 'form_submit btn btn-primary mt-4',
  1762.             ],
  1763.         ]);
  1765.         $pageForm = $pageForm->getForm();
  1767.         return $pageForm;
  1768.     }
  1770.     /**
  1771.      * @Route("/convertImages/and/rename/files/{userSurveyId}", name = "convert_images_rename_files")
  1772.      *
  1773.      * @return Response
  1774.      */
  1775.     public function convertImageAndRenameFiles(Request $request, $userSurveyId)
  1776.     {
  1777.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1779.         if (!$userSurvey) {
  1780.             throw new NotFoundHttpException();
  1781.         }
  1782.         $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/';
  1783.         $filesToConvert = [];
  1784.         $renamed = [];
  1785.         $error = false;
  1786.         $uf = $userSurvey->getUserFile();
  1787.         if (!is_null($uf) && is_dir($path)) {
  1788.             foreach ($uf->getNotArchivedDocuments() as $ufd) {
  1789.                 // rename bad named files
  1790.                 if (is_null($ufd->getFilename())) {
  1791.                     continue;
  1792.                 }
  1793.                 $filename = $ufd->getFilename();
  1794.                 if (!file_exists($path . $filename)) {
  1795.                     $this->addFlash('danger', 'Fichier Introuvable : ' . $filename);
  1796.                     $error = true;
  1798.                     return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  1799.                 }
  1800.                 $basename = pathinfo($filename, PATHINFO_FILENAME);
  1801.                 $ext = pathinfo($filename, PATHINFO_EXTENSION);
  1802.                 $newFilename = $this->pdfService->clean($basename) . '.' . $ext;
  1803.                 $ufd->setFilename($newFilename);
  1804.                 $this->em->persist($ufd);
  1805.                 copy($path . $filename, $path . $newFilename);
  1806.                 $renamed[] = $ufd;
  1808.                 if ($this->pdfService->isImage($path, $newFilename)) {
  1809.                     $filesToConvert[] = $ufd;
  1810.                 }
  1811.             }
  1813.             // saving new filenames
  1814.             $this->em->flush();
  1816.             // check if renamed files are ok.
  1817.             foreach ($renamed as $re) {
  1818.                 if (!file_exists($path . $re->getFileName())) {
  1819.                     $error = true;
  1820.                     $this->addFlash('danger', 'problème lors du renomage : fichier non trouvé !(' . $re->getId() . ')');
  1821.                 }
  1822.             }
  1824.             if (!empty($filesToConvert)) {
  1825.                 foreach ($filesToConvert as $ufd) {
  1826.                     $result = $this->pdfService->imageToPdf($path, $ufd->getFileName());
  1827.                     if (true === $result['result']) {
  1828.                         // save new pdfs
  1829.                         $newUfd = clone $ufd;
  1830.                         $newUfd->setFilename($result['outputFileName']);
  1831.                         $ufd->setIsArchived(true);
  1832.                         foreach ($ufd->getTags() as $tag) {
  1833.                             $newUfd->addTag($tag);
  1834.                         }
  1835.                         $this->em->persist($ufd);
  1836.                         $this->em->persist($newUfd);
  1837.                         $this->em->flush();
  1838.                     } else {
  1839.                         $error = true;
  1840.                         $this->addFlash('danger', "Problème lors de l'appel a ILovePDF : " . $result['msg']);
  1841.                     }
  1842.                 }
  1844.             }
  1845.         }
  1846.         if (!$error) {
  1847.             $this->addFlash('success', 'Fichiers Réparés');
  1848.         }
  1850.         return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  1851.     }
  1853.     /**
  1854.      * @Route("/ajax/createUserSurveyComment/{userSurveyId}", name = "ajax_create_usersurveycomment")
  1855.      */
  1856.     public function ajaxCreateUserSurveyComment(Request $request, $userSurveyId)
  1857.     {
  1858.         $hasError = false;
  1859.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  1860.         if (!$userSurvey) {
  1861.             throw new NotFoundHttpException();
  1862.         }
  1864.         $userSurveyComment = new UserSurveyComment();
  1865.         $userSurveyComment->setUser($this->getUser());
  1866.         $userSurveyComment->setUserSurvey($userSurvey);
  1868.         $userSurveyCommentForm = $this->createForm(
  1869.             UserSurveyCommentType::class,
  1870.             $userSurveyComment,
  1871.             [
  1872.                 'action' => $this->generateUrl('admin_ajax_create_usersurveycomment', ['userSurveyId' => $userSurveyId]),
  1873.             ]
  1874.         );
  1876.         $userSurveyCommentForm->handleRequest($request);
  1877.         if ($userSurveyCommentForm->isSubmitted()) {
  1878.             if ($userSurveyCommentForm->isValid()) {
  1879.                 $userSurveyComment = $userSurveyCommentForm->getData();
  1880.                 $this->em->persist($userSurveyComment);
  1881.                 $this->em->flush();
  1882.                 $this->addFlash('success', 'Commentaire ajouté');
  1883.             } else {
  1884.                 $hasError = true;
  1885.                 $this->addFlash('danger', "le commentaire n'as pas été ajouté");
  1886.             }
  1887.             $source = $request->get('source_url');
  1889.             return $this->redirect($source);
  1890.         }
  1892.         return new JsonResponse($this->renderView('admin/modals/modal_create_edit_comment.html.twig', [
  1893.             'userSurveyCommentForm' => $userSurveyCommentForm->createView(),
  1894.             'hasError' => $hasError,
  1895.         ]));
  1896.     }
  1898.     /**
  1899.      * @Route("/ajax/editUserSurveyComment/{userSurveyCommentId}", name = "ajax_edit_usersurveycomment")
  1900.      */
  1901.     public function ajaxEditUserSurveyComment(Request $request, $userSurveyCommentId)
  1902.     {
  1903.         $hasError = false;
  1904.         $userSurveyComment = $this->em->getRepository(UserSurveyComment::class)->find($userSurveyCommentId);
  1905.         if (!$userSurveyComment) {
  1906.             throw new NotFoundHttpException();
  1907.         }
  1908.         $userSurveyCommentForm = $this->createForm(
  1909.             UserSurveyCommentType::class,
  1910.             $userSurveyComment,
  1911.             [
  1912.                 'action' => $this->generateUrl('admin_ajax_edit_usersurveycomment', ['userSurveyCommentId' => $userSurveyCommentId]),
  1913.             ]
  1914.         );
  1916.         $userSurveyCommentForm->handleRequest($request);
  1917.         if ($userSurveyCommentForm->isSubmitted()) {
  1918.             if ($userSurveyCommentForm->isValid()) {
  1919.                 $userSurveyComment = $userSurveyCommentForm->getData();
  1920.                 $userSurveyComment->setDateUpdate(new DateTime());
  1921.                 $this->em->persist($userSurveyComment);
  1922.                 $this->em->flush();
  1923.                 $this->addFlash('success', 'Commentaire modifié');
  1924.             } else {
  1925.                 $hasError = true;
  1926.                 $this->addFlash('danger', "le commentaire n'as pas été modifié");
  1927.             }
  1928.             $source = $request->get('source_url');
  1930.             return $this->redirect($source);
  1931.         }
  1933.         return new JsonResponse($this->renderView('admin/modals/modal_create_edit_comment.html.twig', [
  1934.             'userSurveyCommentForm' => $userSurveyCommentForm->createView(),
  1935.             'hasError' => $hasError,
  1936.         ]));
  1937.     }
  1939.     /**
  1940.      * @Route("/ajax/deleteUserSurveyComment/{userSurveyCommentId}", name = "ajax_delete_usersurveycomment")
  1941.      *
  1942.      * @param Request $request
  1943.      *
  1944.      * @return JsonResponse
  1945.      */
  1946.     public function ajaxDeleteUserSurveyComment($userSurveyCommentId)
  1947.     {
  1948.         $userSurveyComment = $this->em->getRepository(UserSurveyComment::class)->find($userSurveyCommentId);
  1949.         $userSurveyComment->setIsArchived(true);
  1950.         $this->em->persist($userSurveyComment);
  1951.         $this->em->flush();
  1952.         $this->addFlash('success', 'Commentaire supprimé');
  1954.         return new JsonResponse(true);
  1955.     }
  1957.     /**
  1958.      * @Route("/ajax/replyUserSurveyComment/{replyToId}", name = "ajax_reply_usersurveycomment")
  1959.      */
  1960.     public function ajaxReplyUserSurveyComment(Request $request, $replyToId)
  1961.     {
  1962.         $hasError = false;
  1963.         $originalComment = $this->em->getRepository(UserSurveyComment::class)->find($replyToId);
  1964.         if (!$originalComment) {
  1965.             throw new NotFoundHttpException();
  1966.         }
  1968.         $userSurveyComment = new UserSurveyComment();
  1969.         $userSurveyComment->setUser($this->getUser());
  1970.         $userSurveyComment->setUserSurvey($originalComment->getUserSurvey());
  1971.         $userSurveyComment->setReplyTo($originalComment);
  1973.         $userSurveyCommentForm = $this->createForm(
  1974.             UserSurveyCommentType::class,
  1975.             $userSurveyComment,
  1976.             [
  1977.                 'action' => $this->generateUrl('admin_ajax_reply_usersurveycomment', ['replyToId' => $replyToId]),
  1978.             ]
  1979.         );
  1981.         $userSurveyCommentForm->handleRequest($request);
  1982.         if ($userSurveyCommentForm->isSubmitted()) {
  1983.             if ($userSurveyCommentForm->isValid()) {
  1984.                 $userSurveyComment = $userSurveyCommentForm->getData();
  1985.                 $this->em->persist($userSurveyComment);
  1986.                 $this->em->flush();
  1987.                 $this->addFlash('success', 'Commentaire ajouté');
  1988.             } else {
  1989.                 $hasError = true;
  1990.                 $this->addFlash('danger', "le commentaire n'as pas été enregistré");
  1991.             }
  1992.             $source = $request->get('source_url');
  1994.             return $this->redirect($source);
  1995.         }
  1997.         return new JsonResponse($this->renderView('admin/modals/modal_create_edit_comment.html.twig', [
  1998.             'userSurveyCommentForm' => $userSurveyCommentForm->createView(),
  1999.             'hasError' => $hasError,
  2000.         ]));
  2001.     }
  2003.     /**
  2004.      * @Route("/ajax/datelimit/{userSurveyId}",name = "ajax_date_limit")
  2005.      */
  2006.     public function ajaxUserSurveyDateLimit(Request $request, $userSurveyId)
  2007.     {
  2008.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2009.         if (!$userSurvey) {
  2010.             throw new NotFoundHttpException();
  2011.         }
  2012.         $oldDateLimit = $userSurvey->getDateLimit();
  2014.         $form = $this->createForm(UserSurveyDateLimitType::class, $userSurvey, [
  2015.             'action' => $this->generateUrl('admin_ajax_date_limit', [
  2016.                 'userSurveyId' => $userSurveyId,
  2017.             ]),
  2018.         ]);
  2020.         $form->handleRequest($request);
  2021.         if ($form->isSubmitted()) {
  2022.             if ($form->isValid()) {
  2023.                 $userSurvey = $form->getData();
  2024.                 $sendMail = $form->get('sendMail')->getData();
  2026.                 $this->em->persist($userSurvey);
  2027.                 $this->em->flush();
  2028.                 $this->addFlash('success', 'informations sauvegardées');
  2029.                 if ($sendMail && $oldDateLimit != $userSurvey->getDateLimit()) {
  2030.                     $this->emailService->sendDateLimitUpdate($userSurvey);
  2031.                 }
  2032.             }
  2034.             return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  2035.         }
  2037.         return new JsonResponse($this->renderView('admin/modals/userSurveyDateLimitModal.html.twig', [
  2038.             'form' => $form->createView(),
  2039.         ]));
  2040.     }
  2042.     /**
  2043.      * @Route("/paid/on/bexio/{userSurveyId}",name = "paid_on_bexio")
  2044.      */
  2045.     public function paidOnBexio($userSurveyId)
  2046.     {
  2047.         // Petit bouton pour patrice.
  2049.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2050.         if (!$userSurvey) {
  2051.             throw new NotFoundHttpException();
  2052.         }
  2054.         $userSurvey->setPaymentStatus('payedout');
  2056.         $this->em->persist($userSurvey);
  2057.         $this->em->flush();
  2059.         return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  2060.     }
  2062.     /**
  2063.      * @Route("/save/pdf/renovation/{userFilePropertyId}/{userSurveyId}",name = "generate_pdf_renovation")
  2064.      */
  2065.     public function generateRenovationPdf($userFilePropertyId, $userSurveyId)
  2066.     {
  2067.         $userFileProperty = $this->em->getRepository(UserFileProperty::class)->find($userFilePropertyId);
  2068.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2070.         if (!$userFileProperty || !$userSurvey) {
  2071.             throw new NotFoundHttpException();
  2072.         }
  2074.         $userFile = $userFileProperty->getUserFile();
  2075.         if (!$userFileProperty->getRenovations()->isEmpty()) {
  2076.             $url = $this->generateUrl('print_renovation_table', ['userFilePropertyId' => $userFilePropertyId, 'surveyId' => $userSurvey->getSurvey()->getId()], UrlGeneratorInterface::ABSOLUTE_URL);
  2077.             $path = $this->getParameter('webdir') . '/uploads/files/documents/' . $userSurvey->getId() . '/';
  2078.             $outputFileName = $userFileProperty->getFullAddress() . ' Rénovations';
  2080.             $result = $this->pdfService->generateRenovationTablePdf($path, $url, $outputFileName);
  2082.             if ($result['result']) {
  2083.                 $pdf = $result['outputFileName'];
  2085.                 $doc = $this->em->getRepository(Document::class)->findOneBy(['code' => 'TABL_TRAV']);
  2087.                 $documentTag = $userFile->getTag($doc);
  2088.                 $propertyTag = $userFileProperty->getEntityTypeTag();
  2090.                 if (is_null($documentTag)) {
  2091.                     $documentTag = new DocumentTypeTag();
  2092.                     $documentTag->setUserFile($userFile);
  2093.                     $documentTag->setDocument($doc);
  2094.                     $this->em->persist($documentTag);
  2095.                 }
  2097.                 if (is_null($propertyTag)) {
  2098.                     $propertyTag = new EntityTypeTag();
  2099.                     $propertyTag->setUserFileProperty($userFileProperty);
  2100.                     $propertyTag->setUserFile($userFile);
  2101.                     $this->em->persist($propertyTag);
  2102.                 }
  2104.                 $userFileDocument = new UserFileDocument($pdf);
  2105.                 $userFileDocument->addTag($documentTag);
  2106.                 $userFileDocument->addTag($propertyTag);
  2107.                 $userFileDocument->setUserFile($userFile);
  2109.                 $this->em->persist($userFileDocument);
  2110.                 $this->em->flush();
  2111.             } else {
  2112.                 $this->addFlash('danger', "Problème lors de l'appel a ILovePDF : " . $result['msg']);
  2113.             }
  2114.         } else {
  2115.             $this->addFlash('danger', 'Pas de rénovations dans la propriété');
  2116.         }
  2118.         return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurvey->getId()]);
  2119.     }
  2121.     /**
  2122.      * @Route("/document/edit/tags/{userSurveyId}/{userFileDocumentId}",name="document_edit_tags")
  2123.      */
  2124.     public function documentEditTags(Request $request, int $userSurveyId, int $userFileDocumentId): Response
  2125.     {
  2126.         $userFileDocument = $this->em->getRepository(UserFileDocument::class)->find($userFileDocumentId);
  2127.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2129.         if (!$userSurvey || !$userFileDocument) {
  2130.             throw new NotFoundHttpException();
  2131.         }
  2133.         $userFile = $userSurvey->getUserFile();
  2134.         $this->userSurveyService->updateDocumentTags($userFile, $userSurvey);
  2135.         $this->userSurveyService->updateUserFileEntityTags($userFile);
  2136.         $this->em->persist($userFile);
  2137.         $this->em->flush();
  2140.         $tagsForm = $this->createForm(UserFileDocumentTagsType::class, $userFileDocument, [
  2141.             'action' => $this->generateUrl('admin_document_edit_tags', ['userFileDocumentId' => $userFileDocumentId, 'userSurveyId' => $userSurveyId]),
  2142.         ]);
  2144.         $tagsForm->handleRequest($request);
  2145.         if ($tagsForm->isSubmitted()) {
  2146.             if ($tagsForm->isValid()) {
  2147.                 $userFileDocument = $tagsForm->getData();
  2149.                 // get data from the 'documentTags' field
  2150.                 $documentTypeTags = $tagsForm->get('documentTypeTags')->getData();
  2151.                 $entityTypeTags = $tagsForm->get('entityTypeTags')->getData();
  2153.                 $userFileDocument->removeTags();
  2154.                 // handle the $documentTags data manually
  2155.                 // for example, find the Tag entities and add them to the UserFileDocument entity
  2156.                 foreach (explode(',', $documentTypeTags) as $tagData) {
  2157.                     // assuming $tagData contains the ID of a Tag entity
  2158.                     $tag = $this->em->getRepository(Tag::class)->find($tagData);
  2159.                     if ($tag) {
  2160.                         $userFileDocument->addTag($tag);
  2161.                     }
  2162.                 }
  2163.                 foreach (explode(',', $entityTypeTags) as $tagData) {
  2164.                     // assuming $tagData contains the ID of a Tag entity
  2165.                     $tag = $this->em->getRepository(Tag::class)->find($tagData);
  2166.                     if ($tag) {
  2167.                         $userFileDocument->addTag($tag);
  2168.                     }
  2169.                 }
  2171.                 $this->em->persist($userFileDocument);
  2172.                 $this->em->flush();
  2173.             } else {
  2174.                 $errorStr = '';
  2175.                 foreach ($tagsForm->getErrors(true) as $error) {
  2176.                     $errorStr .= $error->getMessage();
  2177.                 }
  2179.                 $this->addFlash('danger', $errorStr);
  2180.             }
  2181.             $source = $request->get('source_url');
  2182.             if ($source) {
  2183.                 return $this->redirect($source);
  2184.             } else {
  2185.                 return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  2186.             }
  2187.         }
  2189.         return new JsonResponse($this->renderView('admin/modals/modalUserFileDocumentTags.html.twig', [
  2190.             'form' => $tagsForm->createView(),
  2191.         ]));
  2192.     }
  2194.     /**
  2195.      * @Route("/test/mail/{userSurveyId}",name = "test_mail")
  2196.      */
  2197.     public function renderMailTest($userSurveyId)
  2198.     {
  2199.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2200.         if (!$userSurvey) {
  2201.             throw new NotFoundHttpException();
  2202.         }
  2204.         $userFile = $userSurvey->getUserFile();
  2206.         return $this->render('email/userSurvey/statusChange/CMU/PROCESSING_FILES_POSTED_CMU.html.twig', [
  2207.             'userSurvey' => $userSurvey,
  2208.         ]);
  2209.     }
  2211.     private function array_diff_recursive($array1, $array2)
  2212.     {
  2213.         $difference = [];
  2214.         foreach ($array1 as $key => $value) {
  2215.             if (is_array($value)) {
  2216.                 if (!isset($array2[$key]) || !is_array($array2[$key])) {
  2217.                     $difference[$key] = $value;
  2218.                 } else {
  2219.                     $new_diff = $this->array_diff_recursive($value, $array2[$key]);
  2220.                     if (!empty($new_diff)) {
  2221.                         $difference[$key] = $new_diff;
  2222.                     }
  2223.                 }
  2224.             } elseif (!array_key_exists($key, $array2) || $array2[$key] !== $value) {
  2225.                 $difference[$key] = $value;
  2226.             }
  2227.         }
  2229.         return $difference;
  2230.     }
  2232.     /**
  2233.      * @Route("/ajax/cmu/invalidCredential/{userSurveyId}", name = "ajax_cmu_invalid_credential")
  2234.      *
  2235.      * @param $userSurveyId
  2236.      */
  2237.     public function ajaxCmuInvalidCredential(Request $request, $userSurveyId): RedirectResponse|JsonResponse
  2238.     {
  2239.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2240.         if (!$userSurvey) {
  2241.             throw new NotFoundHttpException();
  2242.         }
  2244.         $owner = null;
  2245.         if ($userSurvey->getUserFile()) {
  2246.             $owner = $userSurvey->getUserFile()->getOwner();
  2247.         }
  2249.         if (!$owner) {
  2250.             throw new NotFoundHttpException();
  2251.         }
  2253.         $invalidCredentialForm = $this->createForm(
  2254.             UserFilePersonInvalidCredentialType::class,
  2255.             $owner,
  2256.             [
  2257.                 'action' => $this->generateUrl('admin_ajax_cmu_invalid_credential', ['userSurveyId' => $userSurveyId]),
  2258.             ]
  2259.         );
  2260.         $invalidCredentialForm->handleRequest($request);
  2261.         if ($invalidCredentialForm->isSubmitted()) {
  2262.             if ($invalidCredentialForm->isValid()) {
  2263.                 $sendMail = $invalidCredentialForm->get('sendMail')->getData();
  2265.                 $owner = $invalidCredentialForm->getData();
  2266.                 $this->em->persist($owner);
  2267.                 $this->em->flush();
  2269.                 if (false === $owner->isHasValidFinanceCredentials()) {
  2270.                     $login = $owner->getAnswerObject('fisc_num');
  2271.                     $password = $owner->getAnswerObject('fisc_password');
  2272.                     if (!is_null($login)) {
  2273.                         $owner->removeUserFileAnswer($login);
  2274.                         $this->em->remove($login);
  2275.                     }
  2276.                     if (!is_null($password)) {
  2277.                         $owner->removeUserFileAnswer($password);
  2278.                         $this->em->remove($password);
  2279.                     }
  2280.                     $this->em->flush();
  2281.                 }
  2283.                 if (false === $owner->isHasValidUrssafCredentials()) {
  2284.                     $login = $owner->getAnswerObject('login_urssaf');
  2285.                     $password = $owner->getAnswerObject('pasword_urssaf');
  2286.                     if (!is_null($login)) {
  2287.                         $owner->removeUserFileAnswer($login);
  2288.                         $this->em->remove($login);
  2289.                     }
  2290.                     if (!is_null($password)) {
  2291.                         $owner->removeUserFileAnswer($password);
  2292.                         $this->em->remove($password);
  2293.                     }
  2294.                     $this->em->flush();
  2295.                 }
  2297.                 if (false === $owner->isHasValidPartnerUrssafCredentials()) {
  2298.                     $login = $owner->getAnswerObject('login_ursaf_conjoint');
  2299.                     $password = $owner->getAnswerObject('password_urssaf_conjoint');
  2300.                     if (!is_null($login)) {
  2301.                         $owner->removeUserFileAnswer($login);
  2302.                         $this->em->remove($login);
  2303.                     }
  2304.                     if (!is_null($password)) {
  2305.                         $owner->removeUserFileAnswer($password);
  2306.                         $this->em->remove($password);
  2307.                     }
  2308.                     $this->em->flush();
  2309.                 }
  2311.                 if (false === $owner->isHasValidFinanceCredentials() ||
  2312.                     false === $owner->isHasValidUrssafCredentials() ||
  2313.                     false === $owner->isHasValidPartnerUrssafCredentials()
  2314.                 ) {
  2315.                     $status = $this->em->getRepository(UserSurveyStatus::class)->findOneBy(['code' => 'PROCESSING_FILES_MISSING']);
  2316.                     $userSurvey->setUserSurveyStatus($status);
  2317.                     $this->em->persist($userSurvey);
  2318.                     $this->em->flush();
  2319.                 }
  2321.                 if ($sendMail) {
  2322.                     $this->emailService->sendUserSurveyStatusChange($userSurvey);
  2323.                 }
  2325.                 $this->addFlash('success', 'Identifiants invalide sauvegardés');
  2326.             } else {
  2327.                 $this->addFlash('danger', 'Identifiants invalide non sauvegardés');
  2328.             }
  2329.             $source = $request->get('source_url');
  2331.             return $this->redirect($source);
  2332.         }
  2334.         return new JsonResponse($this->renderView('admin/modals/modal_create_edit_comment.html.twig', [
  2335.             'userSurveyCommentForm' => $invalidCredentialForm->createView(),
  2336.         ]));
  2337.     }
  2340.     /**
  2341.      * @Route("/badPayer/change/{userId}", name = "bad_payer_change")
  2342.      */
  2343.     public function badPayerChange($userId)
  2344.     {
  2346.         $user = $this->em->getRepository(User::class)->find($userId);
  2347.         if (!$user) {
  2348.             throw new NotFoundHttpException();
  2349.         }
  2351.         if ($user->isBadPayer() === true) {
  2352.             $user->setBadPayer(false);
  2353.         } else {
  2354.             $user->setBadPayer(true);
  2355.         }
  2357.         $this->em->persist($user);
  2358.         $this->em->flush();
  2361.         return $this->redirectToRoute('admin_customer_summary_index', ['userId' => $userId]);
  2363.     }
  2365.     /**
  2366.      * @Route("/generate/rs/pdf/{userSurveyId}/{test}", name = "generate_rs_pdf")
  2367.      */
  2368.     public function generateRsPDF($userSurveyId, $test)
  2369.     {
  2371.         if ($test == 1) {
  2372.             $test = true;
  2373.         } else {
  2374.             $test = false;
  2375.         }
  2377.         $userSurvey = $this->em->getRepository(UserSurvey::class)->find($userSurveyId);
  2379.         $pdfContent = $this->rsPdfService->generatePdf($userSurvey, $test);
  2381.         if (!$pdfContent) {
  2382.             return $this->redirectToRoute('admin_usersurvey_display', ['id' => $userSurveyId]);
  2383.         }
  2386.         return new Response($pdfContent, 200, [
  2387.             'Content-Type' => 'application/pdf',
  2388.             'Content-Disposition' => 'inline; filename="impression_RS.pdf"'
  2389.         ]);
  2391.     }
  2393. }