src/Controller/SycMessagesAndPlanning.php line 833

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