src/Controller/SycMessagesAndPlanning.php line 784

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\FileMessage;
  6. use App\Entity\FileMission;
  7. use App\Entity\Message;
  8. use App\Entity\User;
  9. use App\Entity\MessageReaction;
  10. use App\Entity\DiscussionGroup;
  11. use Symfony\Component\Uid\Uuid;
  12. use App\Entity\GroupMessage;
  13. use App\Entity\Mission;
  14. use App\Entity\WorkflowStep;
  15. use App\Form\GroupMessageType;
  16. use App\Entity\Campaign;
  17. use App\Enum\AdminMail;
  18. use App\Enum\Role;
  19. use App\Event\User\UserReactionEvent;
  20. use Symfony\Component\Serializer\SerializerInterface;
  21. use App\Form\MessageType;
  22. use App\Form\MissionParticipantDelaisType;
  23. use App\Repository\MessageReactionRepository;
  24. use App\Repository\MessageRepository;
  25. use App\Repository\MissionRepository;
  26. use App\Repository\UserRepository;
  27. use App\Repository\WorkflowStepRepository;
  28. use App\Repository\CampaignRepository;
  29. use App\Repository\FileMessageRepository;
  30. use App\Repository\MissionParticipantRepository;
  31. use App\Service\MessageService;
  32. use App\Service\NotificationService;
  33. use Doctrine\ORM\EntityManagerInterface;
  34. use Psr\Log\LoggerInterface;
  35. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  36. use Symfony\Component\Filesystem\Filesystem;
  37. use Symfony\Component\HttpFoundation\JsonResponse;
  38. use Symfony\Component\HttpFoundation\Request;
  39. use Symfony\Component\HttpFoundation\Response;
  40. use Symfony\Component\Routing\Annotation\Route;
  41. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  42. use Symfony\Component\Mime\Address;
  43. use Twig\Environment;
  44. use App\Service\GoogleStorageService;
  45. use App\Service\MissionParticipantService;
  46. use App\Service\PriceService;
  47. use App\Service\ChatService;
  48. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  49. use App\EventSubscriber\GroupeMessageSubscriber;
  50. use App\Event\Chat\GroupedMessageSentEvent;
  51. use VSC\API\FileHandler;
  52. use App\Event\VirusCamp\VirusCampEvent;
  53. use App\Event\VirusCamp\FileInfectedEvent;
  55. #[Route('/messages', name: 'messages')]
  56. class SycMessagesAndPlanning extends AbstractController
  57. {
  60.     public function __construct(
  61.         private Environment $twig,
  62.         private EntityManagerInterface $entityManagerInterface,
  63.         private Filesystem $filesystem,
  64.         private MessageService $messageService,
  65.         private LoggerInterface $logger,
  66.         private MessageRepository $messageRepository,
  67.         private MessageReactionRepository $messageReactionRepository,
  68.         private EventDispatcherInterface $dispatcher,
  69.         private NotificationService $notificationService,
  70.         private MissionParticipantService $missionParticipantService,
  71.         private UserRepository $userRepository,
  72.         private GoogleStorageService $googleStorageService,
  73.         private MissionParticipantRepository $missionParticipantRepository,
  74.         private PriceService $priceService,
  75.         private ChatService $chatService,
  76.         private SerializerInterface $serializer,
  78.     ) {
  79.     }
  81.     #[Route('/update/user-who-read/{lastIdMessage}', name: 'user_who_read')]
  83.     public function userWhoReadUpdate(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository)
  84.     {
  85.         $lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
  86.         $message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
  87.         $groupMessageId = $request->query->get('group-message-id');
  88.         $missionId = $request->query->get('mission-id');
  89.         $mission = $missionRepository->findOneBy(["id" => $missionId]);
  90.         $group = null;
  91.         if (null !== $groupMessageId) {
  92.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
  93.         }
  95.         $this->chatService->publishMessageNotificationCampaign(
  96.             $mission->getId(),
  97.             [
  98.                 'message' => [],
  99.                 'html' => "",
  100.                 'type' => 'insert',
  101.                 'planning' => "",
  102.                 'currentUser' => $this->getUser()->getId(),
  103.             ],
  104.             $group
  105.         );
  107.         return new JsonResponse([
  108.                 'status' => "ok",
  109.             ]);
  111.     }
  112.     #[Route('/last/{lastIdMessage}-{nbMessage}', name: 'last')]
  114.     public function lastMessages(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository, $nbMessage = 10)
  115.     {
  117.         if ($this->getUser() == null) {
  118.             return new JsonResponse([
  119.                 'status' => "KO",
  120.             ], Response::HTTP_UNAUTHORIZED);
  121.         }
  123.         $unredMessage = $request->query->get('unred-message');
  124.         $missionId = $request->query->get('mission-id');
  125.         $currentRouteName=$request->query->get('current-route-name');
  126.         $estimatedIncome = $request->query->get('estimatedIncome');
  127.         $timeZone = $request->query->get('time-zone');
  128.         $groupMessageId = $request->query->get('group-message-id');
  129.         $keyword = $request->query->get('keyword');
  130.         $ids = $request->query->get('ids');
  132.        
  134.         $group = null;
  135.         if (null !== $groupMessageId) {
  136.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
  137.         }
  141.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  142.         $isLoadMore = $request->query->get('is-load-more'); 
  143.         $lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
  145.         $messageIdsDeleted = [] ; 
  146.         $fileMessageIdsDeleted = []; 
  147.         $messagesEditing = []; 
  148.         $messagesWithReactions = []; 
  149.        
  150.         $mission = $missionRepository->findOneBy(["id" => $missionId]);
  152.         //special requete pour voir les prochain message contenant les keywords peut alterer donc le nombre limite des messages a affiché.
  153.         $dateLastMessageForSearchWord = '';
  154.         $idLastMessageGet = '';
  155.         if (!empty($keyword)) {
  156.             $nextMessageDate = $messageRepository->getNextMessageWithCritarea($mission->getCampaign(),$group,$keyword,json_decode($ids));
  157.             if (!is_null($nextMessageDate)) {
  158.                 $dateLastMessageForSearchWord = $nextMessageDate['createdAt'];
  159.                 $idLastMessageGet = $nextMessageDate['idMessage'];
  160.             }
  161.             
  162.         }
  163.         //$countNbMessge = $this->entityManagerInterface->getRepository
  164.         //fin special requete 
  165.         $idLastMessageToGetinSearch = null;
  166.         $listOfUserTyping = $this->messageService->getUserTypingWithoutCurrentUser($mission);
  167.         $userTypingWithDuration = $this->messageService->calculaTimeTypingOfEachUser($listOfUserTyping);
  168.         if(is_null($userTypingWithDuration)){
  169.             $userTypingWithDuration = [];
  170.         }
  171.         $message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
  172.         $nbMessageAfterSearch = null;
  173.         if ($mission != null) {
  174.             if($isLoadMore == "true" || $message == null){
  175.                 $listLastMessage = $messageRepository->getAllMessage($mission->getCampaign(),$nbMessage,$group,$dateLastMessageForSearchWord);
  176.                   if (!empty($keyword)) {//pour la recherche 
  177.                     $nbMessageAfterSearch = count($listLastMessage);
  178.                  }
  179.             }
  180.             else{
  181.                 $listLastMessage =$messageRepository->findLastMessage($mission->getCampaign(), $message->getCreatedAt(),$group);
  182.                 $messageIdsDeleted = $messageRepository->findIdsMessageDeleted($mission->getCampaign(),$group) ; 
  183.                 $fileMessageIdsDeleted = $fileMessageRepository->findIdsFileMessageDeleted($mission->getCampaign());
  185.                 $messagesEditing= $messageRepository->findMessagesEditing($mission->getCampaign(),$group) ; 
  186.                 $messagesWithReactions= $messageRepository->findMessageWithReaction($mission->getCampaign(),$group) ; 
  188.             }
  190.             $nbAllMessage = $messageRepository->nbAllMessage($mission->getCampaign(),$group)['nb'];
  191.             
  192.          
  193.                 usort($listLastMessage, function($a, $b) {
  194.                     $dateA = ($a->getCreatedAt()->getTimestamp());
  195.                     $dateB = ($b->getCreatedAt()->getTimestamp());
  196.                     return   $dateA - $dateB ; 
  197.                 });
  198.             //pour la recherche 
  199.             if (!empty($keyword)) {
  200.                $idLastMessageToGetinSearch = $listLastMessage[0]?->getId();
  201.             }
  203.             $missionParticipant = null;
  204.             foreach ($mission->getParticipants() as $participant) {
  205.                 if ($participant->getUser()->getId() == $this->getUser()->getId()) {
  206.                     $missionParticipant = $participant;
  207.                 }
  208.             }
  209.             $lastTenMessages = $messageRepository->getLastTenMessages($mission->getCampaign(),$group); 
  210.             $listIdsLastMessage = $this->getIdsMessage($lastTenMessages); 
  211.             $futuresActions = $this->missionParticipantService->getUniqByFutureActions($mission->getCampaign()->getId(),$this->getUser()->getId()); 
  213.             return new JsonResponse([
  214.                 "status" => "ok",
  215.                 "nbMessageAfterSearch" => $nbMessageAfterSearch,
  216.                 "html" => $this->getHtmlToRenderInView(mission: $mission, listLastMessage: $listLastMessage, timeZone: $timeZone, dateOffSetHour: $dateOffSetHour, unredMessage: $unredMessage,nbAllMessage: $nbAllMessage,group:$group),
  217.                 "lists_last_message_id"=>$listIdsLastMessage['message_ids'],
  218.                 "lists_last_file_message_id"=>$listIdsLastMessage['file_message_ids'],
  219.                 "planning" => $this->twig->render("mission/_planning_item.html.twig", [
  220.                     "mission" => $mission,
  221.                     "campaign" => $mission->getCampaign(),
  222.                     "userConnected" => $this->getUser(),
  223.                     "missionParticipant" => $missionParticipant,
  225.                 ]),
  226.                 "list_user_read_last_message"=>$this->userReadLastMessage($messageRepository->findOneBy(['campaign' => $mission->getCampaign()], ['createdAt' => 'DESC'])), 
  227.                 "message_deleted_ids"=> $messageIdsDeleted,
  228.                 'user_typing' => $this->getUserTypingMessage($userTypingWithDuration), 
  229.                 "file_message_deleted_ids"=> $fileMessageIdsDeleted, 
  230.                 "messages_editing"=>$messagesEditing,
  231.                 "messages_with_reactions"=>$this->getElementReactions($messagesWithReactions),
  232.                 "futureActions" =>  $this->getHtmlFutureActions($mission, $futuresActions, $currentRouteName, $estimatedIncome),
  233.                 "idLastMessage" => $idLastMessageGet,
  234.                 "idLastMessageToGetinSearch" => $idLastMessageToGetinSearch,
  236.             ]);
  241.         }
  242.         // $this->sendEmailError('-', '-', 'L\'id de la mission est null');
  244.         return new JsonResponse(["status" => "ko"], 200);
  245.     }
  246.     #[Route('/count-all-message-correspondence', name: 'count_all_search_message_correspondence')]
  247.     public function countAllSearchMessageCorrespondence(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, MessageRepository $messageRepository,UserRepository $userRepository){
  248.         $groupId = $request->query->get('groupId');
  249.         $missionId = $request->query->get('missionId');
  250.         $search = $request->query->get('search');
  251.         $mission = $missionRepository->findOneBy(criteria: ["id" => $missionId]);
  252.         $group = null;
  253.         if (!empty($groupId) && !is_null($groupId)) {
  254.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  255.         }
  256.         $listLastMessage = $messageRepository->getAllMessageWithCritarea($mission->getCampaign(),$group,$search);
  257.         return new JsonResponse([
  258.             'status' => "ok",
  259.             'nb' => count($listLastMessage)
  260.         ]);
  261.     }
  263.     #[Route('/delete/{id}', name: 'detele_message', methods: ['POST'])]
  265.     public function deleteMessages(Message $message,Request $request)
  266.     {
  267.         $groupId = $request->query->get('groupId');
  268.         $group = null;
  269.         if (!empty($groupId) && !is_null($groupId)) {
  270.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  271.         }
  272.         if ($message->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  273.             $message->setIsDeleted(true);
  274.             $this->entityManagerInterface->flush();
  275.             //ecoute de suppression
  276.             $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  277.             //fin ecoute
  278.              $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  279.                 "message" => "",
  280.                 'idMission' => $message->getMission()->getId(),
  281.                 'group' => !is_null($group) ? $group->getId() : "",
  282.                 'type' => 'message-unread'
  283.             ]);
  284.             return new JsonResponse([
  285.                 'status' => "ok"
  286.             ]);
  287.         }
  289.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  290.     }
  292.     #[Route('/delete/file/{id}', name: 'detele_file_message', methods: ['POST'])]
  295.     public function deleteFileMessages(FileMessage $fileMessage, GoogleStorageService $googleStorageService,Request $request)
  296.     {
  297.         $groupId = $request->query->get('groupId');
  298.         $group = null;
  299.         if (!empty($groupId) && !is_null($groupId)) {
  300.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  301.         }
  302.         if ($fileMessage->getMessages()->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  303.             $message = $fileMessage->getMessages();
  305.             //delete file if in storage
  306.             $company = $message->getCampaign()->getCompany();
  308.             $campaign = $message->getCampaign();
  309.             $bucketName = "company-" . strtolower($company->getId());
  310.             $fileName = "Campaigns/" . $campaign->getId() . "/" . $fileMessage->getName();
  312.             //end delete in google storage
  314.             $fileMessage->setIsDeleted(true);
  315.             $this->entityManagerInterface->flush();
  317.             $file = $this->messageService->getFileMissionUrl($fileMessage->getMessages()->getMission(), $fileMessage->getName());
  319.             if ($message->getContent() == null && $fileMessage->getMessages()->getFileMessages()!=null && $this->messageService->allFileMessageIsDeleted($fileMessage->getMessages())) {
  320.                 $message->setIsDeleted(true);
  321.                 $this->entityManagerInterface->flush();
  322.             }
  323.             try {
  324.                 $this->filesystem->remove($file);
  325.             } catch (\Throwable $th) {
  326.                 $this->logger->error("can't delete file in $file");
  327.             }
  329.             $googleStorageService->deleteFile($bucketName, $fileName);
  330.             //ecoute de suppression fichier message
  331.             $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  332.             $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  333.                 "message" => "",
  334.                 'idMission' => $campaign->getMissions()->first()->getId(),
  335.                 'group' => !is_null($group) ? $group->getId() : "",
  336.                 'type' => 'message-unread'
  337.             ]);
  338.             //fin ecoute
  339.             return new JsonResponse([
  340.                 'status' => "ok"
  341.             ]);
  342.         }
  344.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  345.     }
  347.     #[Route('/emoji/toggle/{id}', name: 'toggle_emoji_reaction', methods: ['POST', 'GET'])]
  349.     public function toggleEmojiReaction(Message $message, Request $request): JsonResponse
  350.     {
  351.         $groupId = $request->query->get('groupId');
  352.         $group = null;
  353.         if (!empty($groupId) && !is_null($groupId)) {
  354.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  355.         }
  356.         $user = $this->getUser();
  357.         if ($user != null) {
  360.             $emoji = $request->request->get('emoji');
  361.             $emojiId = $request->request->get('emojiId');
  362.             $campaignOfMessage = $message->getCampaign();
  364.             $messageReaction = $this->messageReactionRepository->findReactionByUser(messageId: $message->getId(), userId: $user->getId(), emojiId: $emojiId);
  365.             if ($messageReaction != null) {
  366.                 $message->removeMessageReaction($messageReaction[0]);
  367.                 $this->entityManagerInterface->remove($messageReaction[0]);
  368.                 $this->entityManagerInterface->flush();
  369.             } else {
  370.                 $newReaction = new MessageReaction();
  371.                 $newReaction->setEmoji($emoji);
  372.                 $newReaction->setUser($user);
  373.                 $newReaction->setEmojiId(intval($emojiId));
  374.                 $newReaction->setMessage($message);
  375.                 $message->addMessageReaction($newReaction);
  376.                 $this->entityManagerInterface->persist($newReaction);
  377.                 $this->entityManagerInterface->flush();
  378.                 $event = new UserReactionEvent($message->getUser(), $this->getUser(), $message, $newReaction->getEmoji(),$campaignOfMessage);
  379.                 $this->dispatcher->dispatch($event, UserReactionEvent::NAME);
  380.             }
  381.             $mission = $message->getMission();
  382.             $renderContent = $this->chatService->getHtmlContentToRenderInViewForLastMessage($mission,$message,0);
  384.             $this->chatService->publishMessageNotificationCampaign(
  385.                 $mission->getId(),
  386.                 [
  387.                     'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  388.                     'html'=>$renderContent,
  389.                     'type'=>'update',
  390.                     
  391.                 ],$group);
  392.             return new JsonResponse([
  393.                 'status' => "ok",
  394.                 'id_user' => $user->getId()
  395.             ]);
  396.         }
  398.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  399.     }
  402.     #[Route('/send/error', name: 'send_error', methods: ['POST'])]
  403.     public function sendError(Request $request)
  404.     {
  406.         $this->messageService->sendEmailError($request->request->get('xhr'), $request->request->get('type'), $request->request->get('message'));
  407.         return new JsonResponse([]);
  408.     }
  410.     #[Route('/get/user/who/read/{id}', name: '_get_message_user_who_read', methods: ['GET'])]
  411.     public function whoRead(Message $message, Request $request, MessageRepository $messageRepository)
  412.     {
  413.         $userIdsread = $this->messageService->getBullUsersWhoReadMessage($message);
  415.         $userIdsData = [];
  416.         foreach ($userIdsread as $user) {
  417.             $userIdsData[] = $user->getId();
  418.         }
  419.         return new JsonResponse([
  420.             'status' => 'ok',
  421.             'userWhoReadIds' => $userIdsData,
  422.             "messageId" => $message->getId(),
  423.             'userId' => $request->query->get('currentUserId'),
  424.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  425.         ]);
  427.     }
  429.     #[Route('/get/message/by/user/{idUser}/{idMessage}/{dateOffsetHour}', name: '_get_message_for_user_by_id', methods: ['GET'])]
  430.     public function getMessageByUser($idUser, $idMessage,$dateOffsetHour, Request $request, MessageRepository $messageRepository)
  431.     {
  432.         $groupId = $request->query->get('groupId');
  433.         $group = null;
  434.         if (!empty($groupId) && !is_null($groupId)) {
  435.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  436.         }
  438.         $entityManager = $this->getDoctrine()->getManager();
  439.         $user = $entityManager->getRepository(User::class)->find($idUser);
  440.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  442.         $entityManager->flush();
  443.         $message = $entityManager->getRepository(Message::class)->find($idMessage);
  444.         $listUserWhoRead = $message?->getUserListWhoRead();
  445.         $listUserWhoRead[] = $user->getId();
  446.         $message->setUserListWhoRead($listUserWhoRead);
  447.         $entityManager = $this->getDoctrine()->getManager();
  448.         $entityManager->persist($message);
  449.         $entityManager->flush();
  450.         $html = $this->twig->render("mission/_chat_by_item_for_listener.html.twig", [
  451.             "message" => $message,
  452.             "mission" => $message->getMission(),
  453.             "date_off_setHour" => abs($dateOffsetHour),
  454.             "user" => $user
  455.         ]);
  457.         //mise a jour bloc user who read
  458.          $this->chatService->publishMessageNotificationCampaign(
  459.             $message->getCampaign()->getMissions()->first()->getId(),
  460.             [
  461.                 'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  462.                 'type' => "userWhoRead",
  463.                 'userId' => $user->getId(),
  464.             ],
  465.             $group
  466.         );
  467.         //fin mise a jour 
  469.          //end notification
  470.         return new JsonResponse([
  471.             'status' => 'ok',
  472.             'htmlRender'=> $html,
  473.             "message" => $message,
  474.             'planningRender' => $this->chatService->getHtmlToRenderPlanningByUser($user,$message->getMission()),
  475.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  476.         ]);
  477.     }
  480.     #[Route('/add_group/{id}', name: '_add_group', methods: ['POST'])]
  481.     public function addGroupedMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  482.     {
  483.         $group = new DiscussionGroup();
  484.          $entityManager = $this->getDoctrine()->getManager();
  485.          $formCreatedGroup = $this->createForm(GroupMessageType::class, $group, ['listUser' => $mission->getCampaign()->getAllUserInCampaing()]);
  486.          $formCreatedGroup->handleRequest($request);
  487.         if ($formCreatedGroup->isSubmitted() && $formCreatedGroup->isValid()) {
  488.             $id = Uuid::v4()->toBase58();
  489.             $group = $formCreatedGroup->getData(); 
  490.             $group->setId($id);
  491.             $group->setCreatedBy($this->getUser());
  492.             $group->setCampaign($mission->getCampaign());
  493.             $entityManager = $this->getDoctrine()->getManager();
  495.             
  497.             $group->addUser($this->getUser());
  498.             $entityManager->persist($group);
  499.             $entityManager->flush();
  502.             //envoyer des message au utilisateur du groupe
  503.             foreach ($group->getUsers() as $user) {
  504.                 if ($this->getUser()->getId() != $user->getId()) {
  505.                     $userInstance = $entityManager->getRepository(User::class)->find($user->getId());
  506.                     
  507.                     $event = new GroupedMessageSentEvent($group,$userInstance);
  508.                     $this->dispatcher->dispatch($event, GroupedMessageSentEvent::NAME);
  509.                 }
  510.             }
  511.             //fin envoie de messag
  513.             $this->chatService->publishOnDiscussionGroupUpdate('add',$group);
  514.             
  515.             $this->addFlash(
  516.                 type: 'success',
  517.                 message: "Groupe créé avec succès !",
  518.             ); 
  519.             //redirection vers la page list mission avec message de confirmation
  520.             return $this->redirectToRoute('mission_discussion_group', ['id' => $mission->getCampaign()->getMissions()?->first()?->getId(),'groupId'=>$group->getId()], Response::HTTP_SEE_OTHER);
  521.         }
  522.         $this->addFlash(
  523.                 type: 'error',
  524.                 message: "Erreur lors de la création du groupe",
  525.             ); 
  526.         return $this->redirectToRoute('mission_edit', ['id' => $mission->getCampaign()->getMissionsWithoutEspaceDeDiscussion()?->first()?->getId()], Response::HTTP_SEE_OTHER);
  527.     }
  528.     #[Route('/add/{id}', name: '_add', methods: ['POST'])]
  529.     public function addMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  530.     {
  532.         $message = new Message();
  533.         $typeMessage = "insert";
  534.         $entityManager = $this->getDoctrine()->getManager();
  535.         $path = 'file_message_directory';
  536.         $form = $this->createForm(MessageType::class, $message);
  537.         $form->handleRequest($request);
  538.         $error_id_message = $request->query->get('error_id_message', null);
  539.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  540.         $groupId = $request->query->get('groupId');
  541.         $group = null;
  542.         if (!empty($groupId) && !is_null($groupId)) {
  543.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  544.         }
  546.         $messageInsered = $messageRepository->findOneBy(['id' => $error_id_message]);
  547.         if ($form->isSubmitted() && $form->isValid() && $messageInsered == null or ($path = 'file_message_directory')) {
  548.             $errorMessage = "";
  549.             $errorCode = 200;
  551.             try {
  553.                 $idMessage = $request->query->get('id-message');
  554.                 $replyTo = $request->query->get('id-reply-message');
  556.                 if ($idMessage != "") {
  557.                     $typeMessage = "update";
  558.                     $messagePersisted = $messageRepository->findOneBy(['id' => $idMessage]);
  559.                     $messagePersisted->setIsModified(true);
  560.                     $messagePersisted->setContent($message->getContent(), false);
  561.                     $message = $messagePersisted;
  562.                 } else {
  563.                     $message->setUser($this->getUser())
  564.                         ->setCampaign($mission->getCampaign())
  565.                         ->setMission(mission: $mission)
  566.                         ->setUserListWhoRead([$this->getUser()->getId()])
  567.                         ->setOriginalContent($message->getContent());
  568.                         ;
  569.                     if (!is_null($group)) {
  570.                         $message->setDiscussionGroup($group);
  571.                     }
  572.                     $entityManager->persist($message);
  573.                 }
  575.                 if ($replyTo != "") {
  576.                     $replyedMessage = $messageRepository->findOneBy(['id' => $replyTo]);
  577.                     $message->setReplyToWithMessage($replyedMessage);
  578.                 }
  579.                  $entityManager->persist($message);
  580.                  $entityManager->flush();
  581.                
  583.                 $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $message);
  585.                 // Publication des notifications
  586.                 $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  587.                 $timezone = new \DateTimeZone(date_default_timezone_get());
  589.                 $utcCokkieInDays = $request->cookies->get('utcCokkieInDays');
  590.     
  591.                 if ($utcCokkieInDays) {
  592.                    $offsetInHours = $utcCokkieInDays;
  593.                 }else{
  594.                     $offsetInHours = 0;
  595.                 }
  597.                
  598.                 $this->chatService->publishMessageNotificationCampaign(
  599.                     $mission->getId(),
  600.                     [
  601.                         'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  602.                         'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $message, $offsetInHours),
  603.                         'type' => $typeMessage,
  604.                         'planning' => $renderPlanning,
  605.                         'currentUser' => $this->getUser()->getId(),
  606.                     ],
  607.                     $group
  608.                 );
  610.                 $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  611.                     "message" => "",
  612.                     'idMission' => $mission->getId(),
  613.                     'group' => !is_null($group) ? $group->getId() : "",
  614.                     'type' => 'message-unread'
  615.                 ]);
  617.                 $drapDrop = $request->query->get('drag-drop');
  618.                 $files = !is_null($request->query->get('drag-drop')) && $request->query->get('drag-drop') == 1 
  619.                     ? $request->files->get('file') 
  620.                     : $form->get('fileMessages')->getData();
  622.                 // Vérification des fichiers
  623.                 if (!empty($files) && sizeof($files) > 0) {
  624.                     foreach ($files as $file) {
  625.                         // Création d'un nouveau message pour chaque fichier
  626.                         $newMessage = new Message();
  627.                         $newMessage->setUser($this->getUser())
  628.                             ->setCampaign($mission->getCampaign())
  629.                             ->setMission($mission)
  630.                             ->setUserListWhoRead([$this->getUser()->getId()])
  631.                             ->setOriginalContent($message->getContent());
  632.                         
  633.                         if (!is_null($group)) {
  634.                             $newMessage->setDiscussionGroup($group);
  635.                         }
  637.                         // Traitement du fichier
  638.                         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  639.                         $extension = $nameSplitByDot != null && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  640.                         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/', "", $file->getMimeType());
  641.                         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  642.                         $destination = $this->getParameter($path) . '/' . $mission->getId() . '/message';
  643.                         $originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  644.                         $newFilename = $originalFilename . '-' . uniqid() . '.' . $extension;
  646.                         // Upload du fichier
  647.                         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  648.                         
  649.                         // Création de l'objet FileMessage
  650.                         $fileMessage = new FileMessage();
  651.                         $fileMessage->setName($newFilename);
  652.                         $fileMessage->setIsNew(1);
  653.                         $fileMessage->setType($type);
  654.                         $fileMessage->setIsNotInfected(true);
  655.                         $newMessage->addFileMessage($fileMessage);
  657.                         // Persister le message
  658.                         $entityManager->persist($newMessage);
  660.                         // Notification par email pour les mentions dans le tchat
  661.                         $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $newMessage);
  663.                         // Publication des notifications
  664.                         $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  665.                         $this->chatService->publishMessageNotificationCampaign(
  666.                             $mission->getId(),
  667.                             [
  668.                                 'message' => $this->serializer->normalize($newMessage, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  669.                                 'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $newMessage, $offsetInHours),
  670.                                 'type' => $typeMessage,
  671.                                 'planning' => $renderPlanning,
  672.                                 'currentUser' => $this->getUser()->getId(),
  673.                             ],
  674.                             $group
  675.                         );
  677.                         $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  678.                             "message" => "",
  679.                             'idMission' => $mission->getId(),
  680.                             'group' => !is_null($group) ? $group->getId() : "",
  681.                             'type' => 'message-unread'
  682.                         ]);
  683.                     }
  684.                     $entityManager->flush();
  685.                 }else {
  686.                     $errorMessage = "Empty content or no files provided.";
  687.                 }
  688.             } catch (\Throwable $e) {
  689.                 $errorMessage = "Throwable: " . $e->getMessage();
  690.                 $errorCode = 500;
  691.                 $this->messageService->sendEmailError('exception', $e->getMessage(), "message : {$message->getContent()}  mission : {$mission->getId()}");
  692.             }
  694.             return new JsonResponse([
  695.                 'status' => $errorMessage == "" ? 'ok' : 'ko',
  696.                 'message_id' => $message->getId(),
  697.                 'message' => $errorMessage == "" ? 'Enregistré avec succès' : $errorMessage,
  698.             ], $errorCode);
  699.         }
  701.         return new JsonResponse([
  702.             'status' => 'ko',
  703.             'message_id' => $message->getId(),
  704.             'message' => 'Formulaire invalide',
  705.         ], Response::HTTP_UNAUTHORIZED);
  707.     }
  709.     #[Route('/verify/virus-camp/file', name: '_verify_virus_camp_file', methods: ['POST'])]
  710.     public function verifyFile(Request $request){
  711.         //new file
  712.          $fileHandler = new FileHandler;
  713.          $errorGetInScan = [];
  715.          if (!empty($_FILES)) {
  716.              foreach ($_FILES as $file) {
  717.                  $result = $fileHandler->resultsScan($file,"input");
  718.                  if (!empty($result)) {
  719.                     $errorGetInScan[$file['name']] = ['result'=>$result];
  720.                  }
  721.              }
  722.          }
  723.          if (!empty($errorGetInScan) and $this->getUser()!= null) {
  724.              $event = new VirusCampEvent($this->getUser(),$errorGetInScan ,null);
  725.              $this->dispatcher->dispatch($event, VirusCampEvent::NAME);
  726.          }
  727.         
  728.          return new JsonResponse([
  729.             'status' => 'ok',
  730.             'errorGetInScan' => $errorGetInScan
  731.         ]);
  732.     }
  734.     #[Route('/verify/virus-camp/link', name: '_verify_virus_camp_link', methods: ['GET'])]
  735.     public function verifyLink(Request $request,EntityManagerInterface $entityManager){
  736.          //old file
  737.         $fileHandler = new FileHandler;
  738.         $errorGetInScan = [];
  739.         $fileLink = $request->query->get('fileUrl'); 
  740.         $fileName = $request->query->get('fileName'); 
  741.         $result = $fileHandler->resultsScan($fileLink,"urlOrDir");
  742.         if (!empty($result)) {
  743.             $errorGetInScan[$fileName] = ['result'=>$result];
  744.         }
  746.         if (!empty($errorGetInScan)) {
  747.              //get file by name
  748.             $fileMessage = $entityManager->getRepository(FileMessage::class)->findOneBy(['name' => $fileName]);
  749.             $fileCampaign = $entityManager->getRepository(FileMission::class)->findOneBy(['name' => $fileName]);
  750.             $file = null !== $fileMessage ? $fileMessage : $fileCampaign ;
  751.             $event = new FileInfectedEvent($this->getUser(),$errorGetInScan ,$file);
  753.             $this->dispatcher->dispatch($event, FileInfectedEvent::NAME);
  755.         }
  757.         return new JsonResponse([
  758.             'status' => 'ok',
  759.             'errorGetInScan' => $errorGetInScan
  760.         ]);
  761.     }
  762.  
  764.     #[Route('/unread/{id}', name: '_unread', methods: ['POST','GET'])]
  765.     public function messageUnread(Request $request, Mission $mission, MessageRepository $messageRepository)
  766.     {   
  767.         $entityManager = $this->getDoctrine()->getManager();
  768.         $groupId = $request->query->get('groupId'); 
  769.         $userId = $request->query->get('userId'); 
  770.         $group = null;
  771.         $user = $entityManager->getRepository(User::class)->find($userId);
  772.         if (!empty($groupId) && !is_null($groupId)) {
  773.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  774.         }  
  775.         return new JsonResponse([
  776.             'status' => 'ko',
  777.             'missionId' => $mission->getId(),
  778.             'groupId' => $groupId,
  779.             'nombreUnread' => $this->messageService->getNumberMessageUnread(mission: $mission,groupedMessage : $group,user : $user)
  780.         ]);
  782.     }
  783.     #[Route('/unread-all/{id}', name: '_unread_all', methods: ['POST','GET'])]
  784.     public function messageUnreadAll(Request $request, Mission $mission, MessageRepository $messageRepository)
  785.     {   
  786.         $entityManager = $this->getDoctrine()->getManager();
  787.         $userId = $request->query->get('userId'); 
  788.         return new JsonResponse([
  789.             'status' => 'ok',
  790.             'missionId' => $mission->getId(),
  791.             'campaignId' => $mission->getCampaign()->getId(),
  792.             'nombreUnread' => $this->messageService->getNumberAllMessageUnread(mission: $mission,groupedMessage : null)
  793.         ]);
  795.     }
  796.     
  797.     #[Route('/addaudio/{id}', name: '_add_audio_file', methods: ['POST'])]
  798.     public function addAudioMessageFile(Mission $mission,Request $request, MessageRepository $messageRepository)
  799.     {
  800.         $message = new Message();
  801.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  802.         $entityManager = $this->getDoctrine()->getManager();
  804.         $groupId = $request->query->get('groupId');
  805.         $group = null;
  806.         if (!empty($groupId) && !is_null($groupId)) {
  807.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  808.         }
  810.         $file = $request->files->get('audio');
  811.         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  812.         $extension = $nameSplitByDot && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  813.         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/',"",$file->getMimeType());
  814.         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  815.         $newFilename = 'audio-' . uniqid() . '.' . $extension;
  816.         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  817.         $fileMessage = new FileMessage();
  818.         $fileMessage->setName($newFilename);
  819.         $fileMessage->setIsNew(1);
  820.         $fileMessage->setIsNotInfected(true);
  821.         $fileMessage->setType($type);
  822.         $message->addFileMessage($fileMessage);
  823.         $message->setUser($this->getUser())
  824.             ->setCampaign($mission->getCampaign())
  825.             ->setMission(mission: $mission)
  826.             ->setUserListWhoRead([$this->getUser()->getId()]);
  827.         if (!is_null($group)) {
  828.             $message->setDiscussionGroup($group);
  829.         }
  830.         $entityManager->persist($message);
  831.         $entityManager->flush();
  832.         $this->chatService->publishMessageNotificationCampaign($mission->getId(),[
  833.                 'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  834.                 'html'=>$this->getHtmlToRenderInViewForLastMessage($mission,$message,$dateOffSetHour),'type'=>'insert'],$group);
  835.         return new JsonResponse('ok');
  837.     }
  840.     #[Route('/planning/validation/{type}/{id}/{stepId}', name: '_planning_validation', methods: ['GET'])]
  841.     public function stepValidation(string $type, string $stepId, WorkflowStepRepository $workflowStepRepository, Mission $mission)
  842.     {
  844.         return new JsonResponse([
  845.             'html' => $this->getHtmlValidationStep($type, $mission, $workflowStepRepository->findOneBy(['id' => $stepId]))
  846.         ]);
  847.     }
  848.       private function getHtmlValidationStep(string $type, Mission $mission, WorkflowStep $step)
  849.     {
  850.         return $this->twig->render('mission/_validation_step.html.twig', [
  851.             'type' => $type,
  852.             'mission' => $mission,
  853.             'step' => $step
  854.         ]);
  855.     }
  856.     private function getHtmlToRenderInView(?Mission $mission, array $listLastMessage, string $timeZone, float $dateOffSetHour, bool|null $unredMessage = false,int $nbAllMessage =0,$group = null)
  857.     {
  858.         if (sizeof($listLastMessage) == 0) {
  859.             return "";
  860.         }
  861.         $listLastMessageNoDuble = [];
  862.         $seenMessages = [];
  864.         foreach ($listLastMessage as $message) {
  865.             if ($message->getContent() != null) {
  866.                 $uniqueKey = $message->getContent() . '_' . $message->getCreatedAt()->format('Y-m-d H:i');
  867.                 if (!isset($seenMessages[$uniqueKey])) {
  868.                     $listLastMessageNoDuble[] = $message;
  869.                     $seenMessages[$uniqueKey] = true;
  870.                 }
  871.             }else{
  872.                  $listLastMessageNoDuble[] = $message;
  873.             }
  874.         }
  876.         return $this->twig->render("mission/_chat_item.html.twig", [
  877.             "messages" => $listLastMessage,
  878.             "nbAllMessage" => $nbAllMessage,
  879.             "mission" => $mission,
  880.             "unred_message" => $unredMessage,
  881.             "time_zone" => $timeZone,
  882.             "date_off_setHour" => abs($dateOffSetHour),
  883.             "group" => $group,
  884.             "currentUser" => $this->getUser()
  885.         ]);
  886.     }
  888.      private function getHtmlToRenderInViewForLastMessage(?Mission $mission,$message,$dateOffSetHour)
  889.     {
  890.        
  891.         return $this->twig->render("mission/_chat_by_item.html.twig", [
  892.             "message" => $message,
  893.             "mission" => $mission,
  894.             "date_off_setHour" => abs($dateOffSetHour),
  895.             "currentUser" => $this->getUser()
  896.         ]);
  897.     }
  900.     private function getHtmlFutureActions (Mission $mission, array $futuresActions, ?string $currentRouteName=null, ?string $estimatedIncome=null)
  901.     {   
  902.         $formMissionInitialTimeManually = $this->createForm(MissionParticipantDelaisType::class);
  903.         return $this->twig->render("mission/Ux/_futures_actions.html.twig", [
  904.             'futurActions'=> $futuresActions, 
  905.             'mission'=> $mission,
  906.             'price_service' => $this->priceService,
  907.             'campaign'=> $mission->getCampaign(),
  908.             'currentRouteName'=>$currentRouteName,
  909.             'estimatedIncome'=> $this->getEstimatedIncome(),
  910.             'formMissionInitialTimeManually' => $formMissionInitialTimeManually->createView(),
  911.         ]);
  912.     }
  914.     private function getEstimatedIncome(){
  915.         if ($this->isGranted(Role::ROLE_ADMIN->value)) {
  916.             $priceCampaign = $this->missionParticipantRepository->findByInitialTime();
  917.             $estimatedIncome = [];
  918.             $initialTime = [];
  919.             $price = [];
  920.             foreach ($priceCampaign as $value) {
  921.                 if (!isset($estimatedIncome[$value->getMission()->getId()])) {
  922.                     $estimatedIncome[$value->getMission()->getId()] = [];
  923.                 }
  924.                 $initialTime[$value->getMission()->getId()][] = $value->getInitialTime();
  925.                 $price[$value->getMission()->getId()][] = $value->getEstimatedIncome();
  926.             }
  927.         } elseif ($this->isGranted(Role::ROLE_SUBCONTRACTOR->value)) {
  928.             $visibleCampaign = ['orderedBy' => $this->getUser()];
  929.             $estimatedIncome = $this->missionParticipantRepository->getSubcontractorForUserAndMission($this->getUser());
  930.         } else {
  931.             $estimatedIncome = null;
  932.         }
  933.         return $estimatedIncome;
  934.     }
  935.     private function getIdsMessage(array $listLastMessage){
  936.         $ids = []; 
  937.         $fileIds = []; 
  938.         foreach ($listLastMessage as $key => $message) {
  939.             $ids =[...$ids, $message->getId()]; 
  940.             foreach ($message->getFileMessages() as $fileMessage) {
  941.                 $fileIds =[...$fileIds, $fileMessage->getId()]; 
  942.             }
  943.         }
  946.         return [
  947.             'message_ids'=>$ids, 
  948.             'file_message_ids'=> $fileIds
  949.         ]; 
  950.     }
  951.     private function  getUserTypingMessage(array $user_typing){
  952.         return $this->twig->render('services/messages/user_typing_message.html.twig',[
  953.             'user_typing' => $user_typing
  954.         ]);
  955.     }
  957.     private function getElementReactions(array $messages){
  958.         $listMessageWithReactions = []; 
  960.         foreach ($messages as $key => $message) {
  961.             $listMessageWithReactions = [... $listMessageWithReactions,[
  962.                  'id'=> $message->getId(), 
  963.                  'content'=> $this->messageService->getReactionsHtml($message)
  964.             ]];
  965.         }
  966.         return $listMessageWithReactions ; 
  967.     }
  968.     private function userReadLastMessage(?Message $message=null){
  970.         $userIds = [];
  971.         $users = []; 
  973.         if($message!=null){
  974.             $userIds = $message->getUserListWhoRead();
  975.             $userIds = array_diff($userIds, [$message->getUser()->getId()]);
  976.             $users = $this->userRepository->findByIds($userIds);
  977.         }
  978.         return [
  979.                     'html'=>$this->twig->render('services/messages/users_who_read.html.twig',[
  980.                                 'user_list' => $users
  981.                     ]), 
  982.                     'ids'=>[...$userIds], 
  983.             ]
  984.         
  985.        ;
  986.     }
  988.     function splitChar($string, $lg_max)
  989.     {
  990.         if (strlen($string) > $lg_max) {
  991.             $string = substr($string, 0, $lg_max);
  992.             $last_space = strrpos($string, " ");
  993.             $string = substr($string, 0, $last_space) . "...";
  995.         }
  996.         return $string;
  997.     }
  999.     #[Route('/user/istyping/{id}/{idUser}',name:'user_is_typing')]
  1000.     public function setUserIsTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1001.         
  1002.         $groupId = $request->query->get('groupId');
  1003.         $group = null;
  1004.         if (!empty($groupId) && !is_null($groupId)) {
  1005.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1006.         }
  1007.         //envoyer donnez sur mercure
  1008.         $entityManager = $this->getDoctrine()->getManager();
  1009.         $campaign = $entityManager->getRepository(Campaign::class)->find($id);
  1010.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1011.         $this->chatService->publishMessageNotificationCampaign($campaign->getMissions()->first()->getId(),[
  1012.                 'message'=>"",
  1013.                 'type'=>'isTyping',
  1014.                 'currentUser' => $user->getId(),
  1015.                 'typingRender' => $this->chatService->userTyping($user),
  1016.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1017.             ],$group);
  1018.         //fin envoie
  1019.         return new JsonResponse([
  1020.             'status'=>'ok',
  1021.         ]);
  1022.     }
  1024.     #[Route('/user/isStopTyping/{id}/{idUser}',name:'user_is_stop_typing')]
  1025.     public function setUserIsStopTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1026.         $groupId = $request->query->get('groupId');
  1027.         $group = null;
  1028.         if (!empty($groupId) && !is_null($groupId)) {
  1029.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1030.         }
  1031.         //envoyer donnez sur mercure
  1032.         $entityManager = $this->getDoctrine()->getManager();
  1033.         $mission = $entityManager->getRepository(Mission::class)->find($id);
  1034.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1035.         $this->chatService->publishMessageNotificationCampaign($mission->getId(),[
  1036.                 'message'=>"",
  1037.                 'type'=>'isStopTyping',
  1038.                 'currentUser' => $user->getId(),
  1039.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1040.             ],$group);
  1041.         //fin envoie
  1042.         return new JsonResponse([
  1043.             'status'=>'ok',
  1044.         ]);
  1045.     }
  1047.     #[Route('/pinned/{id}',name:'pinned_message')]
  1048.     public function pinned(Message $message,CampaignRepository $campaignRepository,Request $request){
  1049.         $idCurrentUser = $request->query->get('idCurrentUser');
  1050.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1051.         $message->setInsertPinned(new \DateTime())->addPinnedByUser($user);
  1052.         $this->entityManagerInterface->persist($message);
  1053.         $this->entityManagerInterface->flush();
  1054.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  1055.         $groupId = $request->query->get('groupId');
  1057.         $group = null;
  1058.         if (!empty($groupId) && !is_null($groupId)) {
  1059.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1060.         }
  1061.         //faut prendre les rendu du pinned
  1062.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1063.         //         'message'=>$message->getId(),
  1064.         //         'type'=>'isPinned',
  1065.         //         'currentUser' => $user->getId(),
  1066.         //         'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser())
  1067.         //     ],$group);
  1068.         //fin envoie
  1069.         return new JsonResponse([
  1070.             'status'=>'ok',
  1071.             'message'=>$message->getId(),
  1072.             'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser(),$dateOffSetHour)
  1073.         ]);
  1074.     }
  1076.     #[Route('/pinned-off/{id}',name:'pinned_message_off')]
  1077.     public function pinnedOff(Message $message,CampaignRepository $campaignRepository,Request $request){
  1078.         $idCurrentUser = $request->query->get('idCurrentUser');
  1079.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1080.         $message->removePinnedByUser($user);
  1081.         $this->entityManagerInterface->persist($message);
  1082.         $this->entityManagerInterface->flush();
  1084.         $groupId = $request->query->get('groupId');
  1086.         $group = null;
  1087.         if (!empty($groupId) && !is_null($groupId)) {
  1088.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1089.         }
  1090.         // //faut prendre les rendu du pinned
  1091.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1092.         //     'message'=>$message->getId(),
  1093.         //     'type'=>'isPinnedOff',
  1094.         // ],$group);
  1095.         //fin envoie
  1096.         return new JsonResponse([
  1097.             'status'=>'ok',
  1098.             'message'=>$message->getId(),
  1099.         ]);
  1100.     }
  1102.     
  1105.  
  1106. }