src/Controller/SycMessagesAndPlanning.php line 428

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\Service\CampaignService;
  11. use App\Entity\DiscussionGroup;
  12. use App\Service\DataHasherService;
  13. use Symfony\Component\Uid\Uuid;
  14. use App\Entity\GroupMessage;
  15. use App\Entity\Mission;
  16. use App\Entity\WorkflowStep;
  17. use App\Form\GroupMessageType;
  18. use App\Entity\Campaign;
  19. use App\Enum\AdminMail;
  20. use App\Enum\Role;
  21. use App\Event\User\UserReactionEvent;
  22. use Symfony\Component\Serializer\SerializerInterface;
  23. use App\Form\MessageType;
  24. use App\Form\MissionParticipantDelaisType;
  25. use App\Repository\MessageReactionRepository;
  26. use App\Repository\MessageRepository;
  27. use App\Repository\MissionRepository;
  28. use App\Repository\UserRepository;
  29. use App\Repository\WorkflowStepRepository;
  30. use App\Repository\CampaignRepository;
  31. use App\Repository\FileMessageRepository;
  32. use App\Repository\MissionParticipantRepository;
  33. use App\Service\MessageService;
  34. use App\Service\NotificationService;
  35. use Doctrine\ORM\EntityManagerInterface;
  36. use Psr\Log\LoggerInterface;
  37. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  38. use Symfony\Component\Filesystem\Filesystem;
  39. use Symfony\Component\HttpFoundation\JsonResponse;
  40. use Symfony\Component\HttpFoundation\Request;
  41. use Symfony\Component\HttpFoundation\Response;
  42. use Symfony\Component\Routing\Annotation\Route;
  43. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  44. use Symfony\Component\Mime\Address;
  45. use Twig\Environment;
  46. use App\Service\GoogleStorageService;
  47. use App\Service\MissionParticipantService;
  48. use App\Service\PriceService;
  49. use App\Service\ChatService;
  50. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  51. use App\EventSubscriber\GroupeMessageSubscriber;
  52. use App\Event\Chat\GroupedMessageSentEvent;
  53. use VSC\API\FileHandler;
  54. use App\Event\VirusCamp\VirusCampEvent;
  55. use App\Event\VirusCamp\FileInfectedEvent;
  57. #[Route('/messages', name: 'messages')]
  58. class SycMessagesAndPlanning extends AbstractController
  59. {
  62.     public function __construct(
  63.         private Environment $twig,
  64.         private EntityManagerInterface $entityManagerInterface,
  65.         private Filesystem $filesystem,
  66.         private MessageService $messageService,
  67.         private LoggerInterface $logger,
  68.         private MessageRepository $messageRepository,
  69.         private MessageReactionRepository $messageReactionRepository,
  70.         private EventDispatcherInterface $dispatcher,
  71.         private NotificationService $notificationService,
  72.         private MissionParticipantService $missionParticipantService,
  73.         private UserRepository $userRepository,
  74.         private GoogleStorageService $googleStorageService,
  75.         private MissionParticipantRepository $missionParticipantRepository,
  76.         private PriceService $priceService,
  77.         private ChatService $chatService,
  78.         private SerializerInterface $serializer,
  79.         private CampaignService $campaignService,
  81.     ) {
  82.     }
  84.     #[Route('/update/user-who-read/{lastIdMessage}', name: 'user_who_read')]
  86.     public function userWhoReadUpdate(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository)
  87.     {
  88.         $lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
  89.         $message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
  90.         $groupMessageId = $request->query->get('group-message-id');
  91.         $missionId = $request->query->get('mission-id');
  92.         $mission = $missionRepository->findOneBy(["id" => $missionId]);
  93.         $group = null;
  94.         if (null !== $groupMessageId) {
  95.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
  96.         }
  99.         $this->chatService->publishMessageNotificationCampaignHashed(
  100.             $mission->getId(),
  101.             [
  102.                 'message' => [],
  103.                 'html' => "",
  104.                 'type' => 'insert',
  105.                 'planning' => "",
  106.                 'currentUser' => $this->getUser()->getId(),
  107.             ],
  108.             $group
  109.         );
  111.         return new JsonResponse([
  112.                 'status' => "ok",
  113.             ]);
  115.     }
  116.     #[Route('/last/{lastIdMessage}-{nbMessage}', name: 'last')]
  118.     public function lastMessages(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository, $nbMessage = 10)
  119.     {
  121.         if ($this->getUser() == null) {
  122.             return new JsonResponse([
  123.                 'status' => "KO",
  124.             ], Response::HTTP_UNAUTHORIZED);
  125.         }
  127.         $unredMessage = $request->query->get('unred-message');
  128.         $missionId = $request->query->get('mission-id');
  129.         $currentRouteName=$request->query->get('current-route-name');
  130.         $estimatedIncome = $request->query->get('estimatedIncome');
  131.         $timeZone = $request->query->get('time-zone');
  132.         $groupMessageId = $request->query->get('group-message-id');
  133.         $keyword = $request->query->get('keyword');
  134.         $ids = $request->query->get('ids');
  136.        
  138.         $group = null;
  139.         if (null !== $groupMessageId) {
  140.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
  141.         }
  145.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  146.         $isLoadMore = $request->query->get('is-load-more'); 
  147.         $lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
  149.         $messageIdsDeleted = [] ; 
  150.         $fileMessageIdsDeleted = []; 
  151.         $messagesEditing = []; 
  152.         $messagesWithReactions = []; 
  153.        
  154.         $mission = $missionRepository->findOneBy(["id" => $missionId]);
  156.         //special requete pour voir les prochain message contenant les keywords peut alterer donc le nombre limite des messages a affiché.
  157.         $dateLastMessageForSearchWord = '';
  158.         $idLastMessageGet = '';
  159.         if (!empty($keyword)) {
  160.             $nextMessageDate = $messageRepository->getNextMessageWithCritarea($mission->getCampaign(),$group,$keyword,json_decode($ids));
  161.             if (!is_null($nextMessageDate)) {
  162.                 $dateLastMessageForSearchWord = $nextMessageDate['createdAt'];
  163.                 $idLastMessageGet = $nextMessageDate['idMessage'];
  164.             }
  165.             
  166.         }
  167.         //$countNbMessge = $this->entityManagerInterface->getRepository
  168.         //fin special requete 
  169.         $idLastMessageToGetinSearch = null;
  170.         $listOfUserTyping = $this->messageService->getUserTypingWithoutCurrentUser($mission);
  171.         $userTypingWithDuration = $this->messageService->calculaTimeTypingOfEachUser($listOfUserTyping);
  172.         if(is_null($userTypingWithDuration)){
  173.             $userTypingWithDuration = [];
  174.         }
  175.         $message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
  176.         $nbMessageAfterSearch = null;
  177.         if ($mission != null) {
  178.             if($isLoadMore == "true" || $message == null){
  179.                 $listLastMessage = $messageRepository->getAllMessage($mission->getCampaign(),$nbMessage,$group,$dateLastMessageForSearchWord,$this->getUser());
  180.                   if (!empty($keyword)) {//pour la recherche 
  181.                     $nbMessageAfterSearch = count($listLastMessage);
  182.                  }
  183.             }
  184.             else{
  185.                 $listLastMessage =$messageRepository->findLastMessage($mission->getCampaign(), $message->getCreatedAt(),$group,$this->getUser());
  186.                 $messageIdsDeleted = $messageRepository->findIdsMessageDeleted($mission->getCampaign(),$group,$this->getUser()) ; 
  187.                 $fileMessageIdsDeleted = $fileMessageRepository->findIdsFileMessageDeleted($mission->getCampaign());
  189.                 $messagesEditing= $messageRepository->findMessagesEditing($mission->getCampaign(),$group,$this->getUser()) ; 
  190.                 $messagesWithReactions= $messageRepository->findMessageWithReaction($mission->getCampaign(),$group,$this->getUser()) ; 
  192.             }
  194.             $nbAllMessage = $messageRepository->nbAllMessage($mission->getCampaign(),$group,$this->getUser())['nb'];
  195.             
  196.          
  197.                 usort($listLastMessage, function($a, $b) {
  198.                     $dateA = ($a->getCreatedAt()->getTimestamp());
  199.                     $dateB = ($b->getCreatedAt()->getTimestamp());
  200.                     return   $dateA - $dateB ; 
  201.                 });
  202.             //pour la recherche 
  203.             if (!empty($keyword)) {
  204.                $idLastMessageToGetinSearch = $listLastMessage[0]?->getId();
  205.             }
  207.             $missionParticipant = null;
  208.             foreach ($mission->getParticipants() as $participant) {
  209.                 if ($participant->getUser()->getId() == $this->getUser()->getId()) {
  210.                     $missionParticipant = $participant;
  211.                 }
  212.             }
  213.             $lastTenMessages = $messageRepository->getLastTenMessages($mission->getCampaign(),$group,$this->getUser()); 
  214.             $listIdsLastMessage = $this->getIdsMessage($lastTenMessages); 
  215.             $futuresActions = $this->missionParticipantService->getUniqByFutureActions($mission->getCampaign()->getId(),$this->getUser()->getId()); 
  217.             return new JsonResponse([
  218.                 "status" => "ok",
  219.                 "nbMessageAfterSearch" => $nbMessageAfterSearch,
  220.                 "html" => $this->getHtmlToRenderInView(mission: $mission, listLastMessage: $listLastMessage, timeZone: $timeZone, dateOffSetHour: $dateOffSetHour, unredMessage: $unredMessage,nbAllMessage: $nbAllMessage,group:$group),
  221.                 "lists_last_message_id"=>$listIdsLastMessage['message_ids'],
  222.                 "lists_last_file_message_id"=>$listIdsLastMessage['file_message_ids'],
  223.                 "planning" => $this->twig->render("mission/_planning_item.html.twig", [
  224.                     "mission" => $mission,
  225.                     "campaign" => $mission->getCampaign(),
  226.                     "userConnected" => $this->getUser(),
  227.                     "missionParticipant" => $missionParticipant,
  229.                 ]),
  231.                 "list_user_read_last_message"=>$this->userReadLastMessage(
  232.                     $messageRepository->findLastMessageByCampaign($mission->getCampaign(),$group,$this->getUser()),$group
  233.                 ), 
  235.                 "message_deleted_ids"=> $messageIdsDeleted,
  236.                 'user_typing' => $this->getUserTypingMessage($userTypingWithDuration), 
  237.                 "file_message_deleted_ids"=> $fileMessageIdsDeleted, 
  238.                 "messages_editing"=>$messagesEditing,
  239.                 "messages_with_reactions"=>$this->getElementReactions($messagesWithReactions),
  240.                 "futureActions" =>  $this->getHtmlFutureActions($mission, $futuresActions, $currentRouteName, $estimatedIncome),
  241.                 "idLastMessage" => $idLastMessageGet,
  242.                 "idLastMessageToGetinSearch" => $idLastMessageToGetinSearch,
  244.             ]);
  249.         }
  250.         // $this->sendEmailError('-', '-', 'L\'id de la mission est null');
  252.         return new JsonResponse(["status" => "ko"], 200);
  253.     }
  254.     #[Route('/count-all-message-correspondence', name: 'count_all_search_message_correspondence')]
  255.     public function countAllSearchMessageCorrespondence(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, MessageRepository $messageRepository,UserRepository $userRepository){
  256.         $groupId = $request->query->get('groupId');
  257.         $missionId = $request->query->get('missionId');
  258.         $search = $request->query->get('search');
  259.         $mission = $missionRepository->findOneBy(criteria: ["id" => $missionId]);
  260.         $group = null;
  261.         if (!empty($groupId) && !is_null($groupId)) {
  262.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  263.         }
  264.         $listLastMessage = $messageRepository->getAllMessageWithCritarea($mission->getCampaign(),$group,$search);
  265.         return new JsonResponse([
  266.             'status' => "ok",
  267.             'nb' => count($listLastMessage)
  268.         ]);
  269.     }
  271.     #[Route('/delete/{id}', name: 'detele_message', methods: ['POST'])]
  273.     public function deleteMessages(Message $message,Request $request)
  274.     {
  275.         $groupId = $request->query->get('groupId');
  276.         $group = null;
  277.         if (!empty($groupId) && !is_null($groupId)) {
  278.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  279.         }
  280.         if ($message->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  281.             $message->setIsDeleted(true);
  282.             $this->entityManagerInterface->flush();
  283.             //ecoute de suppression
  285.             $this->chatService->publishMessageNotificationCampaignHashed($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  286.             //fin ecoute
  287.              $this->chatService->publishNotificationMessageUnread(
  288.                  DataHasherService::hash("message-send-end-not-read")
  289.                 , [
  291.                 "message" => "",
  292.                 'idMission' => $message->getMission()->getId(),
  293.                 'group' => !is_null($group) ? $group->getId() : "",
  294.                 'type' => 'message-unread'
  295.             ]);
  296.             return new JsonResponse([
  297.                 'status' => "ok"
  298.             ]);
  299.         }
  301.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  302.     }
  304.     #[Route('/delete/file/{id}', name: 'detele_file_message', methods: ['POST'])]
  307.     public function deleteFileMessages(FileMessage $fileMessage, GoogleStorageService $googleStorageService,Request $request)
  308.     {
  309.         $groupId = $request->query->get('groupId');
  310.         $group = null;
  311.         if (!empty($groupId) && !is_null($groupId)) {
  312.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  313.         }
  314.         if ($fileMessage->getMessages()->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  315.             $message = $fileMessage->getMessages();
  317.             //delete file if in storage
  318.             $company = $message->getCampaign()->getCompany();
  320.             $campaign = $message->getCampaign();
  321.             $bucketName = "company-" . strtolower($company->getId());
  322.             $fileName = "Campaigns/" . $campaign->getId() . "/" . $fileMessage->getName();
  324.             //end delete in google storage
  326.             $fileMessage->setIsDeleted(true);
  327.             $this->entityManagerInterface->flush();
  329.             $file = $this->messageService->getFileMissionUrl($fileMessage->getMessages()->getMission(), $fileMessage->getName());
  331.             if ($message->getContent() == null && $fileMessage->getMessages()->getFileMessages()!=null && $this->messageService->allFileMessageIsDeleted($fileMessage->getMessages())) {
  332.                 $message->setIsDeleted(true);
  333.                 $this->entityManagerInterface->flush();
  334.             }
  335.             try {
  336.                 $this->filesystem->remove($file);
  337.             } catch (\Throwable $th) {
  338.                 $this->logger->error("can't delete file in $file");
  339.             }
  341.             $googleStorageService->deleteFile($bucketName, $fileName);
  342.             //ecoute de suppression fichier message
  344.             $this->chatService->publishMessageNotificationCampaignHashed($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  345.             $this->chatService->publishNotificationMessageUnread(
  346.                  DataHasherService::hash("message-send-end-not-read"), [
  348.                 "message" => "",
  349.                 'idMission' => $campaign->getMissions()->first()->getId(),
  350.                 'group' => !is_null($group) ? $group->getId() : "",
  351.                 'type' => 'message-unread'
  352.             ]);
  353.             //fin ecoute
  354.             return new JsonResponse([
  355.                 'status' => "ok"
  356.             ]);
  357.         }
  359.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  360.     }
  362.     #[Route('/emoji/toggle/{id}', name: 'toggle_emoji_reaction', methods: ['POST', 'GET'])]
  364.     public function toggleEmojiReaction(Message $message, Request $request): JsonResponse
  365.     {
  366.         $groupId = $request->query->get('groupId');
  367.         $group = null;
  368.         if (!empty($groupId) && !is_null($groupId)) {
  369.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  370.         }
  371.         $user = $this->getUser();
  372.         if ($user != null) {
  375.             $emoji = $request->request->get('emoji');
  376.             $emojiId = $request->request->get('emojiId');
  377.             $campaignOfMessage = $message->getCampaign();
  379.             $messageReaction = $this->messageReactionRepository->findReactionByUser(messageId: $message->getId(), userId: $user->getId(), emojiId: $emojiId);
  380.             if ($messageReaction != null) {
  381.                 $message->removeMessageReaction($messageReaction[0]);
  382.                 $this->entityManagerInterface->remove($messageReaction[0]);
  383.                 $this->entityManagerInterface->flush();
  384.             } else {
  385.                 $newReaction = new MessageReaction();
  386.                 $newReaction->setEmoji($emoji);
  387.                 $newReaction->setUser($user);
  388.                 $newReaction->setEmojiId(intval($emojiId));
  389.                 $newReaction->setMessage($message);
  390.                 $message->addMessageReaction($newReaction);
  391.                 $this->entityManagerInterface->persist($newReaction);
  392.                 $this->entityManagerInterface->flush();
  393.                 $event = new UserReactionEvent($message->getUser(), $this->getUser(), $message, $newReaction->getEmoji(),$campaignOfMessage,$newReaction );
  394.                 $this->dispatcher->dispatch($event, UserReactionEvent::NAME);
  395.             }
  396.             $mission = $message->getMission();
  397.             $renderContent = $this->chatService->getHtmlContentToRenderInViewForLastMessage($mission,$message,0);
  400.             $this->chatService->publishMessageNotificationCampaignHashed(
  402.                 $mission->getId(),
  403.                 [
  404.                     'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  405.                     'html'=>$renderContent,
  406.                     'type'=>'update',
  407.                     
  408.                 ],$group);
  409.             return new JsonResponse([
  410.                 'status' => "ok",
  411.                 'id_user' => $user->getId()
  412.             ]);
  413.         }
  415.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  416.     }
  419.     #[Route('/send/error', name: 'send_error', methods: ['POST'])]
  420.     public function sendError(Request $request)
  421.     {
  423.         $this->messageService->sendEmailError($request->request->get('xhr'), $request->request->get('type'), $request->request->get('message'));
  424.         return new JsonResponse([]);
  425.     }
  427.     #[Route('/get/user/who/read/{id}', name: '_get_message_user_who_read', methods: ['GET'])]
  428.     public function whoRead(Message $message, Request $request, MessageRepository $messageRepository)
  429.     {
  430.         $userIdsread = $this->messageService->getBullUsersWhoReadMessage($message);
  432.         $userIdsData = [];
  433.         foreach ($userIdsread as $user) {
  434.             $userIdsData[] = $user->getId();
  435.         }
  436.         return new JsonResponse([
  437.             'status' => 'ok',
  438.             'userWhoReadIds' => $userIdsData,
  439.             "messageId" => $message->getId(),
  440.             'userId' => $request->query->get('currentUserId'),
  441.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  442.         ]);
  444.     }
  446.     #[Route('/get/message/by/user/{idUser}/{idMessage}/{dateOffsetHour}', name: '_get_message_for_user_by_id', methods: ['GET'])]
  447.     public function getMessageByUser($idUser, $idMessage,$dateOffsetHour, Request $request, MessageRepository $messageRepository)
  448.     {
  449.         $groupId = $request->query->get('groupId');
  450.         $group = null;
  451.         if (!empty($groupId) && !is_null($groupId)) {
  452.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  453.         }
  455.         $entityManager = $this->getDoctrine()->getManager();
  456.         $user = $entityManager->getRepository(User::class)->find($idUser);
  457.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  459.         $entityManager->flush();
  460.         $message = $entityManager->getRepository(Message::class)->find($idMessage);
  461.         $listUserWhoRead = $message?->getUserListWhoRead();
  462.         $listUserWhoRead[] = $user->getId();
  463.         $message->setUserListWhoRead($listUserWhoRead);
  464.         $entityManager = $this->getDoctrine()->getManager();
  465.         $entityManager->persist($message);
  466.         $entityManager->flush();
  467.         $html = $this->twig->render("mission/_chat_by_item_for_listener.html.twig", [
  468.             "message" => $message,
  469.             "mission" => $message->getMission(),
  470.             "date_off_setHour" => abs($dateOffsetHour),
  471.             "user" => $user
  472.         ]);
  474.         //mise a jour bloc user who read
  476.          $this->chatService->publishMessageNotificationCampaignHashed(
  478.             $message->getCampaign()->getMissions()->first()->getId(),
  479.             [
  480.                 'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  481.                 'type' => "userWhoRead",
  482.                 'userId' => $user->getId(),
  483.             ],
  484.             $group
  485.         );
  486.         //fin mise a jour 
  488.          //end notification
  489.         return new JsonResponse([
  490.             'status' => 'ok',
  491.             'htmlRender'=> $html,
  492.             "message" => $message,
  493.             'planningRender' => $this->chatService->getHtmlToRenderPlanningByUser($user,$message->getMission()),
  494.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  495.         ]);
  496.     }
  499.     #[Route('/add_group/{id}', name: '_add_group', methods: ['POST'])]
  500.     public function addGroupedMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  501.     {
  502.         $group = new DiscussionGroup();
  503.          $entityManager = $this->getDoctrine()->getManager();
  504.          $formCreatedGroup = $this->createForm(GroupMessageType::class, $group, ['listUser' => $mission->getCampaign()->getAllUserInCampaing()]);
  505.          $formCreatedGroup->handleRequest($request);
  506.         if ($formCreatedGroup->isSubmitted() && $formCreatedGroup->isValid()) {
  507.             $id = Uuid::v4()->toBase58();
  508.             $group = $formCreatedGroup->getData(); 
  509.             $group->setId($id);
  510.             $group->setCreatedBy($this->getUser());
  511.             $group->setCampaign($mission->getCampaign());
  512.             $entityManager = $this->getDoctrine()->getManager();
  514.             
  516.             $group->addUser($this->getUser());
  517.             $entityManager->persist($group);
  518.             $entityManager->flush();
  521.             //envoyer des message au utilisateur du groupe
  522.             foreach ($group->getUsers() as $user) {
  523.                 if ($this->getUser()->getId() != $user->getId()) {
  524.                     $userInstance = $entityManager->getRepository(User::class)->find($user->getId());
  525.                     
  526.                     $event = new GroupedMessageSentEvent($group,$userInstance);
  527.                     $this->dispatcher->dispatch($event, GroupedMessageSentEvent::NAME);
  528.                 }
  529.             }
  530.             //fin envoie de messag
  532.             $this->chatService->publishOnDiscussionGroupUpdate('add',$group);
  533.             
  534.             $this->addFlash(
  535.                 type: 'success',
  536.                 message: "Groupe créé avec succès !",
  537.             ); 
  538.             //redirection vers la page list mission avec message de confirmation
  539.             return $this->redirectToRoute('mission_discussion_group', ['id' => $mission->getCampaign()->getMissions()?->first()?->getId(),'groupId'=>$group->getId()], Response::HTTP_SEE_OTHER);
  540.         }
  541.         $this->addFlash(
  542.                 type: 'error',
  543.                 message: "Erreur lors de la création du groupe",
  544.             ); 
  545.         return $this->redirectToRoute('mission_edit', ['id' => $mission->getCampaign()->getMissionsWithoutEspaceDeDiscussion()?->first()?->getId()], Response::HTTP_SEE_OTHER);
  546.     }
  547.     #[Route('/add/{id}', name: '_add', methods: ['POST'])]
  548.     public function addMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  549.     {
  551.         $message = new Message();
  552.         $typeMessage = "insert";
  553.         $entityManager = $this->getDoctrine()->getManager();
  554.         $path = 'file_message_directory';
  555.         $form = $this->createForm(MessageType::class, $message);
  556.         $form->handleRequest($request);
  557.         $error_id_message = $request->query->get('error_id_message', null);
  558.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  559.         $groupId = $request->query->get('groupId');
  560.         $fileSkipVirusScan = explode('|',$request->query->get('fileSkipVirusScan'));
  561.         $group = null;
  562.         if (!empty($groupId) && !is_null($groupId)) {
  563.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  564.         }
  565.         $messageInsered = $messageRepository->findOneBy(['id' => $error_id_message]);
  566.         if ($form->isSubmitted() && $form->isValid() && $messageInsered == null or ($path = 'file_message_directory')) {
  567.             $errorMessage = "";
  568.             $errorCode = 200;
  570.             try {
  572.                 $idMessage = $request->query->get('id-message');
  573.                 $replyTo = $request->query->get('id-reply-message');
  575.                 if ($idMessage != "") {
  576.                     $typeMessage = "update";
  577.                     $messagePersisted = $messageRepository->findOneBy(['id' => $idMessage]);
  578.                     $messagePersisted->setIsModified(true);
  579.                     $messagePersisted->setContent($message->getContent(), false);
  580.                     $message = $messagePersisted;
  581.                 } else {
  582.                     $message->setUser($this->getUser())
  583.                         ->setCampaign($mission->getCampaign())
  584.                         ->setMission(mission: $mission)
  585.                         ->setUserListWhoRead([$this->getUser()->getId()])
  586.                         ->setOriginalContent($message->getContent());
  587.                         ;
  588.                     if (!is_null($group)) {
  589.                         $message->setDiscussionGroup($group);
  590.                     }
  591.                     $entityManager->persist($message);
  592.                 }
  594.                 if ($replyTo != "") {
  595.                     $replyedMessage = $messageRepository->findOneBy(['id' => $replyTo]);
  596.                     $message->setReplyToWithMessage($replyedMessage);
  597.                 }
  598.                  $entityManager->persist($message);
  599.                  $entityManager->flush();
  600.                
  602.                 $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $message);
  604.                 // Publication des notifications
  605.                 $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  606.                 $timezone = new \DateTimeZone(date_default_timezone_get());
  608.                 $utcCokkieInDays = $request->cookies->get('utcCokkieInDays');
  609.     
  610.                 if ($utcCokkieInDays) {
  611.                    $offsetInHours = $utcCokkieInDays;
  612.                 }else{
  613.                     $offsetInHours = 0;
  614.                 }
  616.                
  618.                 $this->chatService->publishMessageNotificationCampaignHashed(
  620.                     $mission->getId(),
  621.                     [
  622.                         'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  623.                         'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $message, $offsetInHours),
  624.                         'type' => $typeMessage,
  625.                         'planning' => $renderPlanning,
  626.                         'currentUser' => $this->getUser()->getId(),
  627.                     ],
  628.                     $group
  629.                 );
  632.                 $this->chatService->publishNotificationMessageUnread(
  633.                      DataHasherService::hash("message-send-end-not-read"), [
  635.                     "message" => "",
  636.                     'idMission' => $mission->getId(),
  637.                     'group' => !is_null($group) ? $group->getId() : "",
  638.                     'type' => 'message-unread'
  639.                 ]);
  641.                 $drapDrop = $request->query->get('drag-drop');
  642.                 $files = !is_null($request->query->get('drag-drop')) && $request->query->get('drag-drop') == 1 
  643.                     ? $request->files->get('file') 
  644.                     : $form->get('fileMessages')->getData();
  645.                
  646.                 // Vérification des fichiers
  647.                 if (!empty($files) && sizeof($files) > 0) {
  648.                     foreach ($files as $file) {
  649.                         // Création d'un nouveau message pour chaque fichier
  650.                         $newMessage = new Message();
  651.                         $newMessage->setUser($this->getUser())
  652.                             ->setCampaign($mission->getCampaign())
  653.                             ->setMission($mission)
  654.                             ->setUserListWhoRead([$this->getUser()->getId()])
  655.                             ->setOriginalContent($message->getContent());
  656.                         
  657.                         if (!is_null($group)) {
  658.                             $newMessage->setDiscussionGroup($group);
  659.                         }
  660.                         
  661.                         // Traitement du fichier
  662.                         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  663.                         $extension = $nameSplitByDot != null && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  664.                         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/', "", $file->getMimeType());
  665.                         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  666.                         $destination = $this->getParameter($path) . '/' . $mission->getId() . '/message';
  667.                         $originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  668.                         $newFilename = $originalFilename . '-' . uniqid() . '.' . $extension;
  669.                         
  670.                         // Upload du fichier
  671.                         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  672.                         
  673.                         // Création de l'objet FileMessage
  674.                         $fileMessage = new FileMessage();
  675.                         $fileMessage->setName($newFilename);
  676.                         $fileMessage->setIsNew(1);
  677.                         $fileMessage->setType($type);
  680.                         if (!in_array($originalFilename.".".$extension, $fileSkipVirusScan) ) {
  681.                             $fileMessage->setIsNotInfected(true);
  682.                         }
  683.                         $newMessage->addFileMessage($fileMessage);
  685.                         // Persister le message
  686.                         $entityManager->persist($newMessage);
  688.                         // Notification par email pour les mentions dans le tchat
  689.                         $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $newMessage);
  691.                         // Publication des notifications
  692.                         $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  694.                         $this->chatService->publishMessageNotificationCampaignHashed(
  696.                             $mission->getId(),
  697.                             [
  698.                                 'message' => $this->serializer->normalize($newMessage, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  699.                                 'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $newMessage, $offsetInHours),
  700.                                 'type' => $typeMessage,
  701.                                 'planning' => $renderPlanning,
  702.                                 'currentUser' => $this->getUser()->getId(),
  703.                             ],
  704.                             $group
  705.                         );
  708.                         $this->chatService->publishNotificationMessageUnread(
  709.                              DataHasherService::hash("message-send-end-not-read"), [
  711.                             "message" => "",
  712.                             'idMission' => $mission->getId(),
  713.                             'group' => !is_null($group) ? $group->getId() : "",
  714.                             'type' => 'message-unread'
  715.                         ]);
  716.                     }
  717.                     $entityManager->flush();
  718.                 }else {
  719.                     $errorMessage = "Empty content or no files provided.";
  720.                 }
  721.             } catch (\Throwable $e) {
  722.                 $errorMessage = "Throwable: " . $e->getMessage();
  723.                 $errorCode = 500;
  724.                 $this->messageService->sendEmailError('exception', $e->getMessage(), "message : {$message->getContent()}  mission : {$mission->getId()}");
  725.             }
  727.             return new JsonResponse([
  728.                 'status' => $errorMessage == "" ? 'ok' : 'ko',
  729.                 'message_id' => $message->getId(),
  730.                 'message' => $errorMessage == "" ? 'Enregistré avec succès' : $errorMessage,
  731.             ], $errorCode);
  732.         }
  734.         return new JsonResponse([
  735.             'status' => 'ko',
  736.             'message_id' => $message->getId(),
  737.             'message' => 'Formulaire invalide',
  738.         ], Response::HTTP_UNAUTHORIZED);
  740.     }
  742.     #[Route('/verify/virus-camp/file', name: '_verify_virus_camp_file', methods: ['POST'])]
  743.     public function verifyFile(Request $request){
  744.         //new file
  745.          $fileHandler = new FileHandler;
  746.          $errorGetInScan = [];
  748.          if (!empty($_FILES)) {
  749.              foreach ($_FILES as $file) {
  750.                  $result = $fileHandler->resultsScan($file,"input");
  751.                  if (!empty($result)) {
  752.                     $errorGetInScan[$file['name']] = ['result'=>$result];
  753.                  }
  754.              }
  755.          }
  756.          if (!empty($errorGetInScan) and $this->getUser()!= null) {
  757.              $event = new VirusCampEvent($this->getUser(),$errorGetInScan ,null);
  758.              $this->dispatcher->dispatch($event, VirusCampEvent::NAME);
  759.          }
  760.         
  761.          return new JsonResponse([
  762.             'status' => 'ok',
  763.             'errorGetInScan' => $errorGetInScan
  764.         ]);
  765.     }
  768.     #[Route('/verify/file-link/virus-camp/{id}/{type}', name: '_verify_virus_camp_file_link', methods: ['GET'])]
  769.     public function verifyFileLink(string $id, string $type='message'){
  771.         $link =""; 
  772.         $fileName = "";
  773.         $errorGetInScan = "";
  774.   
  776.         $fileMessage = $this->entityManagerInterface->getRepository(FileMessage::class)->findOneBy(['id' => $id]);
  779.         if($fileMessage instanceof FileMessage){
  781.                 $message = $fileMessage->getMessages(); 
  782.                 $mission = $message->getMission(); 
  783.                 $file = $fileMessage; 
  784.                
  785.         }else{
  787.             $fileMission = $this->entityManagerInterface->getRepository(FileMission::class)->findOneBy(['id' => $id]);
  788.             $file = $fileMission; 
  789.             $mission = $fileMission->getMission(); 
  790.         }
  791.            
  792.  
  793.         
  794.         $campaign = $mission->getCampaign(); 
  795.         $company = $campaign->getCompany();
  797.         $campaignId= $campaign->getId(); 
  798.         $companyId= $company->getId();
  799.         $fileName = $file->getName(); 
  801.         $nameOfFileinBucket = "Campaigns/$campaignId/$fileName";
  802.         $nameOfBucket = "company-$companyId";
  804.         $link =$this->googleStorageService->getUrlBucket(strtolower($nameOfBucket),$nameOfFileinBucket);
  807.         $fileHandler = new FileHandler;
  808.         $result = $fileHandler->resultsScan($link,"urlOrDir");
  810.         if (!empty($result)) {
  811.             $errorGetInScan[$fileName] = ['result'=>$result];
  812.         }
  814.         if (!empty($errorGetInScan)) {
  815.             $event = new FileInfectedEvent($this->getUser(),$errorGetInScan ,$file);
  816.             $this->dispatcher->dispatch($event, FileInfectedEvent::NAME);
  817.         }else{
  819.             $file->setIsNotInfected(true); 
  820.             $this->entityManagerInterface->flush(); 
  821.         }
  823.        return new JsonResponse([
  824.             'status' => 'ok',
  825.             'errorGetInScan' => $errorGetInScan,
  826.             'link'=> $link,
  827.         ]);
  828.     }
  830.     #[Route('/verify/virus-camp/link', name: '_verify_virus_camp_link', methods: ['GET'])]
  831.     public function verifyLink(Request $request,EntityManagerInterface $entityManager){
  833.         $fileHandler = new FileHandler;
  834.         $errorGetInScan = [];
  835.         $fileLink = $request->query->get('fileUrl'); 
  836.         $fileName = $request->query->get('fileName'); 
  837.         $result = $fileHandler->resultsScan($fileLink,"urlOrDir");
  839.          //old file
  841.         if (!empty($result)) {
  842.             $errorGetInScan[$fileName] = ['result'=>$result];
  843.         }
  845.         if (!empty($errorGetInScan)) {
  846.              //get file by name
  847.             $fileMessage = $entityManager->getRepository(FileMessage::class)->findOneBy(['name' => $fileName]);
  848.             $fileCampaign = $entityManager->getRepository(FileMission::class)->findOneBy(['name' => $fileName]);
  849.             $file = null !== $fileMessage ? $fileMessage : $fileCampaign ;
  850.             $event = new FileInfectedEvent($this->getUser(),$errorGetInScan ,$file);
  852.             $this->dispatcher->dispatch($event, FileInfectedEvent::NAME);
  854.         }
  856.         return new JsonResponse([
  857.             'status' => 'ok',
  858.             'errorGetInScan' => $errorGetInScan
  859.         ]);
  860.     }
  861.  
  863.     #[Route('/unread/{id}', name: '_unread', methods: ['POST','GET'])]
  864.     public function messageUnread(Request $request, Mission $mission, MessageRepository $messageRepository)
  865.     {   
  866.         $entityManager = $this->getDoctrine()->getManager();
  867.         $groupId = $request->query->get('groupId'); 
  868.         $userId = $request->query->get('userId'); 
  869.         $group = null;
  870.         $user = $entityManager->getRepository(User::class)->find($userId);
  871.         if (!empty($groupId) && !is_null($groupId)) {
  872.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  873.         }  
  874.         return new JsonResponse([
  875.             'status' => 'ko',
  876.             'missionId' => $mission->getId(),
  877.             'groupId' => $groupId,
  878.             'nombreUnread' => $this->messageService->getNumberMessageUnread(mission: $mission,groupedMessage : $group,user : $user)
  879.         ]);
  881.     }
  882.     #[Route('/unread-all/{id}', name: '_unread_all', methods: ['POST','GET'])]
  883.     public function messageUnreadAll(Request $request, Mission $mission, MessageRepository $messageRepository)
  884.     {   
  885.         $entityManager = $this->getDoctrine()->getManager();
  886.         $userId = $request->query->get('userId'); 
  887.         return new JsonResponse([
  888.             'status' => 'ok',
  889.             'missionId' => $mission->getId(),
  890.             'campaignId' => $mission->getCampaign()->getId(),
  891.             'nombreUnread' => $this->messageService->getNumberAllMessageUnread(mission: $mission,groupedMessage : null)
  892.         ]);
  894.     }
  895.     
  896.     #[Route('/addaudio/{id}', name: '_add_audio_file', methods: ['POST'])]
  897.     public function addAudioMessageFile(Mission $mission,Request $request, MessageRepository $messageRepository)
  898.     {
  899.         $message = new Message();
  900.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  901.         $entityManager = $this->getDoctrine()->getManager();
  903.         $groupId = $request->query->get('groupId');
  904.         $group = null;
  905.         if (!empty($groupId) && !is_null($groupId)) {
  906.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  907.         }
  909.         $file = $request->files->get('audio');
  910.         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  911.         $extension = $nameSplitByDot && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  912.         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/',"",$file->getMimeType());
  913.         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  914.         $newFilename = 'audio-' . uniqid() . '.' . $extension;
  915.         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  916.         $fileMessage = new FileMessage();
  917.         $fileMessage->setName($newFilename);
  918.         $fileMessage->setIsNew(1);
  919.         $fileMessage->setIsNotInfected(true);
  920.         $fileMessage->setType($type);
  921.         $message->addFileMessage($fileMessage);
  922.         $message->setUser($this->getUser())
  923.             ->setCampaign($mission->getCampaign())
  924.             ->setMission(mission: $mission)
  925.             ->setUserListWhoRead([$this->getUser()->getId()]);
  926.         if (!is_null($group)) {
  927.             $message->setDiscussionGroup($group);
  928.         }
  929.         $entityManager->persist($message);
  930.         $entityManager->flush();
  932.         $this->chatService->publishMessageNotificationCampaignHashed($mission->getId(),[
  934.                 'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  935.                 'html'=>$this->getHtmlToRenderInViewForLastMessage($mission,$message,$dateOffSetHour),'type'=>'insert'],$group);
  936.         return new JsonResponse('ok');
  938.     }
  941.     #[Route('/planning/validation/{type}/{id}/{stepId}', name: '_planning_validation', methods: ['GET'])]
  942.     public function stepValidation(string $type, string $stepId, WorkflowStepRepository $workflowStepRepository, Mission $mission)
  943.     {
  945.         return new JsonResponse([
  946.             'html' => $this->getHtmlValidationStep($type, $mission, $workflowStepRepository->findOneBy(['id' => $stepId]))
  947.         ]);
  948.     }
  949.       private function getHtmlValidationStep(string $type, Mission $mission, WorkflowStep $step)
  950.     {
  952.         return $this->twig->render('mission/_validation_step.html.twig', [
  953.             'type' => $type,
  954.             'mission' => $mission,
  955.             'step' => $step,
  956.             'requirementForClosed' => $this->campaignService->getRequirementToResendOrderToClient($mission->getCampaign())
  957.         ]);
  958.     }
  959.     private function getHtmlToRenderInView(?Mission $mission, array $listLastMessage, string $timeZone, float $dateOffSetHour, bool|null $unredMessage = false,int $nbAllMessage =0,$group = null)
  960.     {
  961.         if (sizeof($listLastMessage) == 0) {
  962.             return "";
  963.         }
  964.         $listLastMessageNoDuble = [];
  965.         $seenMessages = [];
  967.         foreach ($listLastMessage as $message) {
  968.             if ($message->getContent() != null) {
  969.                 $uniqueKey = $message->getContent() . '_' . $message->getCreatedAt()->format('Y-m-d H:i');
  970.                 if (!isset($seenMessages[$uniqueKey])) {
  971.                     $listLastMessageNoDuble[] = $message;
  972.                     $seenMessages[$uniqueKey] = true;
  973.                 }
  974.             }else{
  975.                  $listLastMessageNoDuble[] = $message;
  976.             }
  977.         }
  979.         return $this->twig->render("mission/_chat_item.html.twig", [
  980.             "messages" => $listLastMessage,
  981.             "nbAllMessage" => $nbAllMessage,
  982.             "mission" => $mission,
  983.             "unred_message" => $unredMessage,
  984.             "time_zone" => $timeZone,
  985.             "date_off_setHour" => abs($dateOffSetHour),
  986.             "group" => $group,
  987.             "currentUser" => $this->getUser()
  988.         ]);
  989.     }
  991.      private function getHtmlToRenderInViewForLastMessage(?Mission $mission,$message,$dateOffSetHour)
  992.     {
  993.        
  994.         return $this->twig->render("mission/_chat_by_item.html.twig", [
  995.             "message" => $message,
  996.             "mission" => $mission,
  997.             "date_off_setHour" => abs($dateOffSetHour),
  998.             "currentUser" => $this->getUser()
  999.         ]);
  1000.     }
  1003.     private function getHtmlFutureActions (Mission $mission, array $futuresActions, ?string $currentRouteName=null, ?string $estimatedIncome=null)
  1004.     {   
  1005.         $formMissionInitialTimeManually = $this->createForm(MissionParticipantDelaisType::class);
  1006.         return $this->twig->render("mission/Ux/_futures_actions.html.twig", [
  1007.             'futurActions'=> $futuresActions, 
  1008.             'mission'=> $mission,
  1009.             'price_service' => $this->priceService,
  1010.             'campaign'=> $mission->getCampaign(),
  1011.             'currentRouteName'=>$currentRouteName,
  1012.             'estimatedIncome'=> $this->getEstimatedIncome(),
  1013.             'formMissionInitialTimeManually' => $formMissionInitialTimeManually->createView(),
  1014.         ]);
  1015.     }
  1017.     private function getEstimatedIncome(){
  1018.         if ($this->isGranted(Role::ROLE_ADMIN->value)) {
  1019.             $priceCampaign = $this->missionParticipantRepository->findByInitialTime();
  1020.             $estimatedIncome = [];
  1021.             $initialTime = [];
  1022.             $price = [];
  1023.             foreach ($priceCampaign as $value) {
  1024.                 if (!isset($estimatedIncome[$value->getMission()->getId()])) {
  1025.                     $estimatedIncome[$value->getMission()->getId()] = [];
  1026.                 }
  1027.                 $initialTime[$value->getMission()->getId()][] = $value->getInitialTime();
  1028.                 $price[$value->getMission()->getId()][] = $value->getEstimatedIncome();
  1029.             }
  1030.         } elseif ($this->isGranted(Role::ROLE_SUBCONTRACTOR->value)) {
  1031.             $visibleCampaign = ['orderedBy' => $this->getUser()];
  1032.             $estimatedIncome = $this->missionParticipantRepository->getSubcontractorForUserAndMission($this->getUser());
  1033.         } else {
  1034.             $estimatedIncome = null;
  1035.         }
  1036.         return $estimatedIncome;
  1037.     }
  1038.     private function getIdsMessage(array $listLastMessage){
  1039.         $ids = []; 
  1040.         $fileIds = []; 
  1041.         foreach ($listLastMessage as $key => $message) {
  1042.             $ids =[...$ids, $message->getId()]; 
  1043.             foreach ($message->getFileMessages() as $fileMessage) {
  1044.                 $fileIds =[...$fileIds, $fileMessage->getId()]; 
  1045.             }
  1046.         }
  1049.         return [
  1050.             'message_ids'=>$ids, 
  1051.             'file_message_ids'=> $fileIds
  1052.         ]; 
  1053.     }
  1054.     private function  getUserTypingMessage(array $user_typing){
  1055.         return $this->twig->render('services/messages/user_typing_message.html.twig',[
  1056.             'user_typing' => $user_typing
  1057.         ]);
  1058.     }
  1060.     private function getElementReactions(array $messages){
  1061.         $listMessageWithReactions = []; 
  1063.         foreach ($messages as $key => $message) {
  1064.             $listMessageWithReactions = [... $listMessageWithReactions,[
  1065.                  'id'=> $message->getId(), 
  1066.                  'content'=> $this->messageService->getReactionsHtml($message)
  1067.             ]];
  1068.         }
  1069.         return $listMessageWithReactions ; 
  1070.     }
  1071.     private function userReadLastMessage(?Message $message=null,$group = null){
  1073.         $userIds = [];
  1074.         $users = []; 
  1076.         if($message!=null){
  1077.             foreach ($message->getUserListWhoRead() as $userRead) {
  1078.                 if ($userRead instanceof User) {
  1079.                     $userIds[] = ($userRead->getId());
  1080.                 }else{
  1081.                     $userIds[] = $userRead;
  1082.                 }
  1083.             }
  1084.             //dd($userIds,[$message->getUser()->getId()]);
  1085.             $userIds = array_diff($userIds, [$message->getUser()->getId()]);
  1086.             $users = $this->userRepository->findByIds($userIds);
  1087.         }
  1089.         return [
  1090.                     'html'=>$this->twig->render('services/messages/users_who_read.html.twig',[
  1091.                                 'user_list' => $users,
  1092.                                 'group' => $group
  1093.                     ]), 
  1094.                     'ids'=>[...$userIds], 
  1095.             ]
  1096.         
  1097.        ;
  1098.     }
  1100.     function splitChar($string, $lg_max)
  1101.     {
  1102.         if (strlen($string) > $lg_max) {
  1103.             $string = substr($string, 0, $lg_max);
  1104.             $last_space = strrpos($string, " ");
  1105.             $string = substr($string, 0, $last_space) . "...";
  1107.         }
  1108.         return $string;
  1109.     }
  1111.     #[Route('/user/istyping/{id}/{idUser}',name:'user_is_typing')]
  1112.     public function setUserIsTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1113.         
  1114.         $groupId = $request->query->get('groupId');
  1115.         $group = null;
  1116.         if (!empty($groupId) && !is_null($groupId)) {
  1117.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1118.         }
  1119.         //envoyer donnez sur mercure
  1120.         $entityManager = $this->getDoctrine()->getManager();
  1121.         $campaign = $entityManager->getRepository(Campaign::class)->find($id);
  1122.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1124.         $this->chatService->publishMessageNotificationCampaignHashed($campaign->getMissions()->first()->getId(),[
  1126.                 'message'=>"",
  1127.                 'type'=>'isTyping',
  1128.                 'currentUser' => $user->getId(),
  1129.                 'missionIds'=>array_map(function($item){
  1130.                     return  $item->getId(); 
  1131.                  }, $campaign->getMissions()->toArray()),
  1132.                 'typingRender' => $this->chatService->userTyping($user),
  1133.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1134.             ],$group);
  1135.         //fin envoie
  1136.         return new JsonResponse([
  1137.             'status'=>'ok',
  1138.         ]);
  1139.     }
  1141.     #[Route('/user/isStopTyping/{id}/{idUser}',name:'user_is_stop_typing')]
  1142.     public function setUserIsStopTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1143.         $groupId = $request->query->get('groupId');
  1144.         $group = null;
  1145.         if (!empty($groupId) && !is_null($groupId)) {
  1146.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1147.         }
  1148.         //envoyer donnez sur mercure
  1149.         $entityManager = $this->getDoctrine()->getManager();
  1150.         $mission = $entityManager->getRepository(Mission::class)->find($id);
  1151.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1153.         $this->chatService->publishMessageNotificationCampaignHashed($mission->getId(),[
  1155.                 'message'=>"",
  1156.                 'type'=>'isStopTyping',
  1157.                 'currentUser' => $user->getId(),
  1158.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1159.             ],$group);
  1160.         //fin envoie
  1161.         return new JsonResponse([
  1162.             'status'=>'ok',
  1163.         ]);
  1164.     }
  1166.     #[Route('/pinned/{id}',name:'pinned_message')]
  1167.     public function pinned(Message $message,CampaignRepository $campaignRepository,Request $request){
  1168.         $idCurrentUser = $request->query->get('idCurrentUser');
  1169.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1170.         $message->setInsertPinned(new \DateTime())->addPinnedByUser($user);
  1171.         $this->entityManagerInterface->persist($message);
  1172.         $this->entityManagerInterface->flush();
  1173.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  1174.         $groupId = $request->query->get('groupId');
  1176.         $group = null;
  1177.         if (!empty($groupId) && !is_null($groupId)) {
  1178.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1179.         }
  1180.         //faut prendre les rendu du pinned
  1181.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1182.         //         'message'=>$message->getId(),
  1183.         //         'type'=>'isPinned',
  1184.         //         'currentUser' => $user->getId(),
  1185.         //         'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser())
  1186.         //     ],$group);
  1187.         //fin envoie
  1188.         return new JsonResponse([
  1189.             'status'=>'ok',
  1190.             'message'=>$message->getId(),
  1191.             'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser(),$dateOffSetHour)
  1192.         ]);
  1193.     }
  1195.     #[Route('/pinned-off/{id}',name:'pinned_message_off')]
  1196.     public function pinnedOff(Message $message,CampaignRepository $campaignRepository,Request $request){
  1197.         $idCurrentUser = $request->query->get('idCurrentUser');
  1198.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1199.         $message->removePinnedByUser($user);
  1200.         $this->entityManagerInterface->persist($message);
  1201.         $this->entityManagerInterface->flush();
  1203.         $groupId = $request->query->get('groupId');
  1205.         $group = null;
  1206.         if (!empty($groupId) && !is_null($groupId)) {
  1207.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1208.         }
  1209.         // //faut prendre les rendu du pinned
  1210.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1211.         //     'message'=>$message->getId(),
  1212.         //     'type'=>'isPinnedOff',
  1213.         // ],$group);
  1214.         //fin envoie
  1215.         return new JsonResponse([
  1216.             'status'=>'ok',
  1217.             'message'=>$message->getId(),
  1218.         ]);
  1219.     }
  1221.     
  1224.  
  1225. }