src/Controller/SycMessagesAndPlanning.php line 107

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