src/Controller/SycMessagesAndPlanning.php line 116

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.                 ]),
  229.                 "list_user_read_last_message"=>$this->userReadLastMessage(
  230.                     $messageRepository->findLastMessageByCampaign($mission->getCampaign(),$group,$this->getUser()),$group
  231.                 ), 
  233.                 "message_deleted_ids"=> $messageIdsDeleted,
  234.                 'user_typing' => $this->getUserTypingMessage($userTypingWithDuration), 
  235.                 "file_message_deleted_ids"=> $fileMessageIdsDeleted, 
  236.                 "messages_editing"=>$messagesEditing,
  237.                 "messages_with_reactions"=>$this->getElementReactions($messagesWithReactions),
  238.                 "futureActions" =>  $this->getHtmlFutureActions($mission, $futuresActions, $currentRouteName, $estimatedIncome),
  239.                 "idLastMessage" => $idLastMessageGet,
  240.                 "idLastMessageToGetinSearch" => $idLastMessageToGetinSearch,
  242.             ]);
  247.         }
  248.         // $this->sendEmailError('-', '-', 'L\'id de la mission est null');
  250.         return new JsonResponse(["status" => "ko"], 200);
  251.     }
  252.     #[Route('/count-all-message-correspondence', name: 'count_all_search_message_correspondence')]
  253.     public function countAllSearchMessageCorrespondence(Request $request,FileMessageRepository $fileMessageRepository,  MissionRepository $missionRepository, MessageRepository $messageRepository,UserRepository $userRepository){
  254.         $groupId = $request->query->get('groupId');
  255.         $missionId = $request->query->get('missionId');
  256.         $search = $request->query->get('search');
  257.         $mission = $missionRepository->findOneBy(criteria: ["id" => $missionId]);
  258.         $group = null;
  259.         if (!empty($groupId) && !is_null($groupId)) {
  260.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  261.         }
  262.         $listLastMessage = $messageRepository->getAllMessageWithCritarea($mission->getCampaign(),$group,$search);
  263.         return new JsonResponse([
  264.             'status' => "ok",
  265.             'nb' => count($listLastMessage)
  266.         ]);
  267.     }
  269.     #[Route('/delete/{id}', name: 'detele_message', methods: ['POST'])]
  271.     public function deleteMessages(Message $message,Request $request)
  272.     {
  273.         $groupId = $request->query->get('groupId');
  274.         $group = null;
  275.         if (!empty($groupId) && !is_null($groupId)) {
  276.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  277.         }
  278.         if ($message->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  279.             $message->setIsDeleted(true);
  280.             $this->entityManagerInterface->flush();
  281.             //ecoute de suppression
  282.             $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  283.             //fin ecoute
  284.              $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  285.                 "message" => "",
  286.                 'idMission' => $message->getMission()->getId(),
  287.                 'group' => !is_null($group) ? $group->getId() : "",
  288.                 'type' => 'message-unread'
  289.             ]);
  290.             return new JsonResponse([
  291.                 'status' => "ok"
  292.             ]);
  293.         }
  295.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  296.     }
  298.     #[Route('/delete/file/{id}', name: 'detele_file_message', methods: ['POST'])]
  301.     public function deleteFileMessages(FileMessage $fileMessage, GoogleStorageService $googleStorageService,Request $request)
  302.     {
  303.         $groupId = $request->query->get('groupId');
  304.         $group = null;
  305.         if (!empty($groupId) && !is_null($groupId)) {
  306.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  307.         }
  308.         if ($fileMessage->getMessages()->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
  309.             $message = $fileMessage->getMessages();
  311.             //delete file if in storage
  312.             $company = $message->getCampaign()->getCompany();
  314.             $campaign = $message->getCampaign();
  315.             $bucketName = "company-" . strtolower($company->getId());
  316.             $fileName = "Campaigns/" . $campaign->getId() . "/" . $fileMessage->getName();
  318.             //end delete in google storage
  320.             $fileMessage->setIsDeleted(true);
  321.             $this->entityManagerInterface->flush();
  323.             $file = $this->messageService->getFileMissionUrl($fileMessage->getMessages()->getMission(), $fileMessage->getName());
  325.             if ($message->getContent() == null && $fileMessage->getMessages()->getFileMessages()!=null && $this->messageService->allFileMessageIsDeleted($fileMessage->getMessages())) {
  326.                 $message->setIsDeleted(true);
  327.                 $this->entityManagerInterface->flush();
  328.             }
  329.             try {
  330.                 $this->filesystem->remove($file);
  331.             } catch (\Throwable $th) {
  332.                 $this->logger->error("can't delete file in $file");
  333.             }
  335.             $googleStorageService->deleteFile($bucketName, $fileName);
  336.             //ecoute de suppression fichier message
  337.             $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
  338.             $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  339.                 "message" => "",
  340.                 'idMission' => $campaign->getMissions()->first()->getId(),
  341.                 'group' => !is_null($group) ? $group->getId() : "",
  342.                 'type' => 'message-unread'
  343.             ]);
  344.             //fin ecoute
  345.             return new JsonResponse([
  346.                 'status' => "ok"
  347.             ]);
  348.         }
  350.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  351.     }
  353.     #[Route('/emoji/toggle/{id}', name: 'toggle_emoji_reaction', methods: ['POST', 'GET'])]
  355.     public function toggleEmojiReaction(Message $message, Request $request): JsonResponse
  356.     {
  357.         $groupId = $request->query->get('groupId');
  358.         $group = null;
  359.         if (!empty($groupId) && !is_null($groupId)) {
  360.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  361.         }
  362.         $user = $this->getUser();
  363.         if ($user != null) {
  366.             $emoji = $request->request->get('emoji');
  367.             $emojiId = $request->request->get('emojiId');
  368.             $campaignOfMessage = $message->getCampaign();
  370.             $messageReaction = $this->messageReactionRepository->findReactionByUser(messageId: $message->getId(), userId: $user->getId(), emojiId: $emojiId);
  371.             if ($messageReaction != null) {
  372.                 $message->removeMessageReaction($messageReaction[0]);
  373.                 $this->entityManagerInterface->remove($messageReaction[0]);
  374.                 $this->entityManagerInterface->flush();
  375.             } else {
  376.                 $newReaction = new MessageReaction();
  377.                 $newReaction->setEmoji($emoji);
  378.                 $newReaction->setUser($user);
  379.                 $newReaction->setEmojiId(intval($emojiId));
  380.                 $newReaction->setMessage($message);
  381.                 $message->addMessageReaction($newReaction);
  382.                 $this->entityManagerInterface->persist($newReaction);
  383.                 $this->entityManagerInterface->flush();
  384.                 $event = new UserReactionEvent($message->getUser(), $this->getUser(), $message, $newReaction->getEmoji(),$campaignOfMessage);
  385.                 $this->dispatcher->dispatch($event, UserReactionEvent::NAME);
  386.             }
  387.             $mission = $message->getMission();
  388.             $renderContent = $this->chatService->getHtmlContentToRenderInViewForLastMessage($mission,$message,0);
  390.             $this->chatService->publishMessageNotificationCampaign(
  391.                 $mission->getId(),
  392.                 [
  393.                     'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  394.                     'html'=>$renderContent,
  395.                     'type'=>'update',
  396.                     
  397.                 ],$group);
  398.             return new JsonResponse([
  399.                 'status' => "ok",
  400.                 'id_user' => $user->getId()
  401.             ]);
  402.         }
  404.         return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
  405.     }
  408.     #[Route('/send/error', name: 'send_error', methods: ['POST'])]
  409.     public function sendError(Request $request)
  410.     {
  412.         $this->messageService->sendEmailError($request->request->get('xhr'), $request->request->get('type'), $request->request->get('message'));
  413.         return new JsonResponse([]);
  414.     }
  416.     #[Route('/get/user/who/read/{id}', name: '_get_message_user_who_read', methods: ['GET'])]
  417.     public function whoRead(Message $message, Request $request, MessageRepository $messageRepository)
  418.     {
  419.         $userIdsread = $this->messageService->getBullUsersWhoReadMessage($message);
  421.         $userIdsData = [];
  422.         foreach ($userIdsread as $user) {
  423.             $userIdsData[] = $user->getId();
  424.         }
  425.         return new JsonResponse([
  426.             'status' => 'ok',
  427.             'userWhoReadIds' => $userIdsData,
  428.             "messageId" => $message->getId(),
  429.             'userId' => $request->query->get('currentUserId'),
  430.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  431.         ]);
  433.     }
  435.     #[Route('/get/message/by/user/{idUser}/{idMessage}/{dateOffsetHour}', name: '_get_message_for_user_by_id', methods: ['GET'])]
  436.     public function getMessageByUser($idUser, $idMessage,$dateOffsetHour, Request $request, MessageRepository $messageRepository)
  437.     {
  438.         $groupId = $request->query->get('groupId');
  439.         $group = null;
  440.         if (!empty($groupId) && !is_null($groupId)) {
  441.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  442.         }
  444.         $entityManager = $this->getDoctrine()->getManager();
  445.         $user = $entityManager->getRepository(User::class)->find($idUser);
  446.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  448.         $entityManager->flush();
  449.         $message = $entityManager->getRepository(Message::class)->find($idMessage);
  450.         $listUserWhoRead = $message?->getUserListWhoRead();
  451.         $listUserWhoRead[] = $user->getId();
  452.         $message->setUserListWhoRead($listUserWhoRead);
  453.         $entityManager = $this->getDoctrine()->getManager();
  454.         $entityManager->persist($message);
  455.         $entityManager->flush();
  456.         $html = $this->twig->render("mission/_chat_by_item_for_listener.html.twig", [
  457.             "message" => $message,
  458.             "mission" => $message->getMission(),
  459.             "date_off_setHour" => abs($dateOffsetHour),
  460.             "user" => $user
  461.         ]);
  463.         //mise a jour bloc user who read
  464.          $this->chatService->publishMessageNotificationCampaign(
  465.             $message->getCampaign()->getMissions()->first()->getId(),
  466.             [
  467.                 'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  468.                 'type' => "userWhoRead",
  469.                 'userId' => $user->getId(),
  470.             ],
  471.             $group
  472.         );
  473.         //fin mise a jour 
  475.          //end notification
  476.         return new JsonResponse([
  477.             'status' => 'ok',
  478.             'htmlRender'=> $html,
  479.             "message" => $message,
  480.             'planningRender' => $this->chatService->getHtmlToRenderPlanningByUser($user,$message->getMission()),
  481.             'renderUserWhoRead' => $this->chatService->userWhoRead($message)
  482.         ]);
  483.     }
  486.     #[Route('/add_group/{id}', name: '_add_group', methods: ['POST'])]
  487.     public function addGroupedMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  488.     {
  489.         $group = new DiscussionGroup();
  490.          $entityManager = $this->getDoctrine()->getManager();
  491.          $formCreatedGroup = $this->createForm(GroupMessageType::class, $group, ['listUser' => $mission->getCampaign()->getAllUserInCampaing()]);
  492.          $formCreatedGroup->handleRequest($request);
  493.         if ($formCreatedGroup->isSubmitted() && $formCreatedGroup->isValid()) {
  494.             $id = Uuid::v4()->toBase58();
  495.             $group = $formCreatedGroup->getData(); 
  496.             $group->setId($id);
  497.             $group->setCreatedBy($this->getUser());
  498.             $group->setCampaign($mission->getCampaign());
  499.             $entityManager = $this->getDoctrine()->getManager();
  501.             
  503.             $group->addUser($this->getUser());
  504.             $entityManager->persist($group);
  505.             $entityManager->flush();
  508.             //envoyer des message au utilisateur du groupe
  509.             foreach ($group->getUsers() as $user) {
  510.                 if ($this->getUser()->getId() != $user->getId()) {
  511.                     $userInstance = $entityManager->getRepository(User::class)->find($user->getId());
  512.                     
  513.                     $event = new GroupedMessageSentEvent($group,$userInstance);
  514.                     $this->dispatcher->dispatch($event, GroupedMessageSentEvent::NAME);
  515.                 }
  516.             }
  517.             //fin envoie de messag
  519.             $this->chatService->publishOnDiscussionGroupUpdate('add',$group);
  520.             
  521.             $this->addFlash(
  522.                 type: 'success',
  523.                 message: "Groupe créé avec succès !",
  524.             ); 
  525.             //redirection vers la page list mission avec message de confirmation
  526.             return $this->redirectToRoute('mission_discussion_group', ['id' => $mission->getCampaign()->getMissions()?->first()?->getId(),'groupId'=>$group->getId()], Response::HTTP_SEE_OTHER);
  527.         }
  528.         $this->addFlash(
  529.                 type: 'error',
  530.                 message: "Erreur lors de la création du groupe",
  531.             ); 
  532.         return $this->redirectToRoute('mission_edit', ['id' => $mission->getCampaign()->getMissionsWithoutEspaceDeDiscussion()?->first()?->getId()], Response::HTTP_SEE_OTHER);
  533.     }
  534.     #[Route('/add/{id}', name: '_add', methods: ['POST'])]
  535.     public function addMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
  536.     {
  538.         $message = new Message();
  539.         $typeMessage = "insert";
  540.         $entityManager = $this->getDoctrine()->getManager();
  541.         $path = 'file_message_directory';
  542.         $form = $this->createForm(MessageType::class, $message);
  543.         $form->handleRequest($request);
  544.         $error_id_message = $request->query->get('error_id_message', null);
  545.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  546.         $groupId = $request->query->get('groupId');
  547.         $group = null;
  548.         if (!empty($groupId) && !is_null($groupId)) {
  549.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  550.         }
  552.         $messageInsered = $messageRepository->findOneBy(['id' => $error_id_message]);
  553.         if ($form->isSubmitted() && $form->isValid() && $messageInsered == null or ($path = 'file_message_directory')) {
  554.             $errorMessage = "";
  555.             $errorCode = 200;
  557.             try {
  559.                 $idMessage = $request->query->get('id-message');
  560.                 $replyTo = $request->query->get('id-reply-message');
  562.                 if ($idMessage != "") {
  563.                     $typeMessage = "update";
  564.                     $messagePersisted = $messageRepository->findOneBy(['id' => $idMessage]);
  565.                     $messagePersisted->setIsModified(true);
  566.                     $messagePersisted->setContent($message->getContent(), false);
  567.                     $message = $messagePersisted;
  568.                 } else {
  569.                     $message->setUser($this->getUser())
  570.                         ->setCampaign($mission->getCampaign())
  571.                         ->setMission(mission: $mission)
  572.                         ->setUserListWhoRead([$this->getUser()->getId()])
  573.                         ->setOriginalContent($message->getContent());
  574.                         ;
  575.                     if (!is_null($group)) {
  576.                         $message->setDiscussionGroup($group);
  577.                     }
  578.                     $entityManager->persist($message);
  579.                 }
  581.                 if ($replyTo != "") {
  582.                     $replyedMessage = $messageRepository->findOneBy(['id' => $replyTo]);
  583.                     $message->setReplyToWithMessage($replyedMessage);
  584.                 }
  585.                  $entityManager->persist($message);
  586.                  $entityManager->flush();
  587.                
  589.                 $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $message);
  591.                 // Publication des notifications
  592.                 $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  593.                 $timezone = new \DateTimeZone(date_default_timezone_get());
  595.                 $utcCokkieInDays = $request->cookies->get('utcCokkieInDays');
  596.     
  597.                 if ($utcCokkieInDays) {
  598.                    $offsetInHours = $utcCokkieInDays;
  599.                 }else{
  600.                     $offsetInHours = 0;
  601.                 }
  603.                
  604.                 $this->chatService->publishMessageNotificationCampaign(
  605.                     $mission->getId(),
  606.                     [
  607.                         'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  608.                         'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $message, $offsetInHours),
  609.                         'type' => $typeMessage,
  610.                         'planning' => $renderPlanning,
  611.                         'currentUser' => $this->getUser()->getId(),
  612.                     ],
  613.                     $group
  614.                 );
  616.                 $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  617.                     "message" => "",
  618.                     'idMission' => $mission->getId(),
  619.                     'group' => !is_null($group) ? $group->getId() : "",
  620.                     'type' => 'message-unread'
  621.                 ]);
  623.                 $drapDrop = $request->query->get('drag-drop');
  624.                 $files = !is_null($request->query->get('drag-drop')) && $request->query->get('drag-drop') == 1 
  625.                     ? $request->files->get('file') 
  626.                     : $form->get('fileMessages')->getData();
  627.                
  628.                 // Vérification des fichiers
  629.                 if (!empty($files) && sizeof($files) > 0) {
  630.                     foreach ($files as $file) {
  631.                         // Création d'un nouveau message pour chaque fichier
  632.                         $newMessage = new Message();
  633.                         $newMessage->setUser($this->getUser())
  634.                             ->setCampaign($mission->getCampaign())
  635.                             ->setMission($mission)
  636.                             ->setUserListWhoRead([$this->getUser()->getId()])
  637.                             ->setOriginalContent($message->getContent());
  638.                         
  639.                         if (!is_null($group)) {
  640.                             $newMessage->setDiscussionGroup($group);
  641.                         }
  642.                         
  643.                         // Traitement du fichier
  644.                         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  645.                         $extension = $nameSplitByDot != null && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  646.                         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/', "", $file->getMimeType());
  647.                         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  648.                         $destination = $this->getParameter($path) . '/' . $mission->getId() . '/message';
  649.                         $originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  650.                         $newFilename = $originalFilename . '-' . uniqid() . '.' . $extension;
  651.                         
  652.                         // Upload du fichier
  653.                         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  654.                         
  655.                         // Création de l'objet FileMessage
  656.                         $fileMessage = new FileMessage();
  657.                         $fileMessage->setName($newFilename);
  658.                         $fileMessage->setIsNew(1);
  659.                         $fileMessage->setType($type);
  660.                         $fileMessage->setIsNotInfected(true);
  661.                         $newMessage->addFileMessage($fileMessage);
  663.                         // Persister le message
  664.                         $entityManager->persist($newMessage);
  666.                         // Notification par email pour les mentions dans le tchat
  667.                         $this->messageService->sendEmailForParticipantMentionedInTchat($mission, $newMessage);
  669.                         // Publication des notifications
  670.                         $renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
  671.                         $this->chatService->publishMessageNotificationCampaign(
  672.                             $mission->getId(),
  673.                             [
  674.                                 'message' => $this->serializer->normalize($newMessage, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  675.                                 'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $newMessage, $offsetInHours),
  676.                                 'type' => $typeMessage,
  677.                                 'planning' => $renderPlanning,
  678.                                 'currentUser' => $this->getUser()->getId(),
  679.                             ],
  680.                             $group
  681.                         );
  683.                         $this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
  684.                             "message" => "",
  685.                             'idMission' => $mission->getId(),
  686.                             'group' => !is_null($group) ? $group->getId() : "",
  687.                             'type' => 'message-unread'
  688.                         ]);
  689.                     }
  690.                     $entityManager->flush();
  691.                 }else {
  692.                     $errorMessage = "Empty content or no files provided.";
  693.                 }
  694.             } catch (\Throwable $e) {
  695.                 $errorMessage = "Throwable: " . $e->getMessage();
  696.                 $errorCode = 500;
  697.                 $this->messageService->sendEmailError('exception', $e->getMessage(), "message : {$message->getContent()}  mission : {$mission->getId()}");
  698.             }
  700.             return new JsonResponse([
  701.                 'status' => $errorMessage == "" ? 'ok' : 'ko',
  702.                 'message_id' => $message->getId(),
  703.                 'message' => $errorMessage == "" ? 'Enregistré avec succès' : $errorMessage,
  704.             ], $errorCode);
  705.         }
  707.         return new JsonResponse([
  708.             'status' => 'ko',
  709.             'message_id' => $message->getId(),
  710.             'message' => 'Formulaire invalide',
  711.         ], Response::HTTP_UNAUTHORIZED);
  713.     }
  715.     #[Route('/verify/virus-camp/file', name: '_verify_virus_camp_file', methods: ['POST'])]
  716.     public function verifyFile(Request $request){
  717.         //new file
  718.          $fileHandler = new FileHandler;
  719.          $errorGetInScan = [];
  721.          if (!empty($_FILES)) {
  722.              foreach ($_FILES as $file) {
  723.                  $result = $fileHandler->resultsScan($file,"input");
  724.                  if (!empty($result)) {
  725.                     $errorGetInScan[$file['name']] = ['result'=>$result];
  726.                  }
  727.              }
  728.          }
  729.          if (!empty($errorGetInScan) and $this->getUser()!= null) {
  730.              $event = new VirusCampEvent($this->getUser(),$errorGetInScan ,null);
  731.              $this->dispatcher->dispatch($event, VirusCampEvent::NAME);
  732.          }
  733.         
  734.          return new JsonResponse([
  735.             'status' => 'ok',
  736.             'errorGetInScan' => $errorGetInScan
  737.         ]);
  738.     }
  741.     #[Route('/verify/file-link/virus-camp/{id}/{type}', name: '_verify_virus_camp_file_link', methods: ['GET'])]
  742.     public function verifyFileLink(string $id, string $type='message'){
  744.         $link =""; 
  745.         $fileName = "";
  746.         $errorGetInScan = "";
  747.   
  749.         $fileMessage = $this->entityManagerInterface->getRepository(FileMessage::class)->findOneBy(['id' => $id]);
  752.         if($fileMessage instanceof FileMessage){
  754.                 $message = $fileMessage->getMessages(); 
  755.                 $mission = $message->getMission(); 
  756.                 $file = $fileMessage; 
  757.                
  758.         }else{
  760.             $fileMission = $this->entityManagerInterface->getRepository(FileMission::class)->findOneBy(['id' => $id]);
  761.             $file = $fileMission; 
  762.             $mission = $fileMission->getMission(); 
  763.         }
  764.            
  765.  
  766.         
  767.         $campaign = $mission->getCampaign(); 
  768.         $company = $campaign->getCompany();
  770.         $campaignId= $campaign->getId(); 
  771.         $companyId= $company->getId();
  772.         $fileName = $file->getName(); 
  774.         $nameOfFileinBucket = "Campaigns/$campaignId/$fileName";
  775.         $nameOfBucket = "company-$companyId";
  777.         $link =$this->googleStorageService->getUrlBucket(strtolower($nameOfBucket),$nameOfFileinBucket);
  780.         $fileHandler = new FileHandler;
  781.         $result = $fileHandler->resultsScan($link,"urlOrDir");
  783.         if (!empty($result)) {
  784.             $errorGetInScan[$fileName] = ['result'=>$result];
  785.         }
  787.         if (!empty($errorGetInScan)) {
  788.             $event = new FileInfectedEvent($this->getUser(),$errorGetInScan ,$file);
  789.             $this->dispatcher->dispatch($event, FileInfectedEvent::NAME);
  790.         }else{
  792.             $file->setIsNotInfected(true); 
  793.             $this->entityManagerInterface->flush(); 
  794.         }
  796.        return new JsonResponse([
  797.             'status' => 'ok',
  798.             'errorGetInScan' => $errorGetInScan,
  799.             'link'=> $link,
  800.         ]);
  801.     }
  803.     #[Route('/verify/virus-camp/link', name: '_verify_virus_camp_link', methods: ['GET'])]
  804.     public function verifyLink(Request $request,EntityManagerInterface $entityManager){
  806.         $fileHandler = new FileHandler;
  807.         $errorGetInScan = [];
  808.         $fileLink = $request->query->get('fileUrl'); 
  809.         $fileName = $request->query->get('fileName'); 
  810.         $result = $fileHandler->resultsScan($fileLink,"urlOrDir");
  812.          //old file
  814.         if (!empty($result)) {
  815.             $errorGetInScan[$fileName] = ['result'=>$result];
  816.         }
  818.         if (!empty($errorGetInScan)) {
  819.              //get file by name
  820.             $fileMessage = $entityManager->getRepository(FileMessage::class)->findOneBy(['name' => $fileName]);
  821.             $fileCampaign = $entityManager->getRepository(FileMission::class)->findOneBy(['name' => $fileName]);
  822.             $file = null !== $fileMessage ? $fileMessage : $fileCampaign ;
  823.             $event = new FileInfectedEvent($this->getUser(),$errorGetInScan ,$file);
  825.             $this->dispatcher->dispatch($event, FileInfectedEvent::NAME);
  827.         }
  829.         return new JsonResponse([
  830.             'status' => 'ok',
  831.             'errorGetInScan' => $errorGetInScan
  832.         ]);
  833.     }
  834.  
  836.     #[Route('/unread/{id}', name: '_unread', methods: ['POST','GET'])]
  837.     public function messageUnread(Request $request, Mission $mission, MessageRepository $messageRepository)
  838.     {   
  839.         $entityManager = $this->getDoctrine()->getManager();
  840.         $groupId = $request->query->get('groupId'); 
  841.         $userId = $request->query->get('userId'); 
  842.         $group = null;
  843.         $user = $entityManager->getRepository(User::class)->find($userId);
  844.         if (!empty($groupId) && !is_null($groupId)) {
  845.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  846.         }  
  847.         return new JsonResponse([
  848.             'status' => 'ko',
  849.             'missionId' => $mission->getId(),
  850.             'groupId' => $groupId,
  851.             'nombreUnread' => $this->messageService->getNumberMessageUnread(mission: $mission,groupedMessage : $group,user : $user)
  852.         ]);
  854.     }
  855.     #[Route('/unread-all/{id}', name: '_unread_all', methods: ['POST','GET'])]
  856.     public function messageUnreadAll(Request $request, Mission $mission, MessageRepository $messageRepository)
  857.     {   
  858.         $entityManager = $this->getDoctrine()->getManager();
  859.         $userId = $request->query->get('userId'); 
  860.         return new JsonResponse([
  861.             'status' => 'ok',
  862.             'missionId' => $mission->getId(),
  863.             'campaignId' => $mission->getCampaign()->getId(),
  864.             'nombreUnread' => $this->messageService->getNumberAllMessageUnread(mission: $mission,groupedMessage : null)
  865.         ]);
  867.     }
  868.     
  869.     #[Route('/addaudio/{id}', name: '_add_audio_file', methods: ['POST'])]
  870.     public function addAudioMessageFile(Mission $mission,Request $request, MessageRepository $messageRepository)
  871.     {
  872.         $message = new Message();
  873.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  874.         $entityManager = $this->getDoctrine()->getManager();
  876.         $groupId = $request->query->get('groupId');
  877.         $group = null;
  878.         if (!empty($groupId) && !is_null($groupId)) {
  879.             $group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
  880.         }
  882.         $file = $request->files->get('audio');
  883.         $nameSplitByDot = explode('.', $file->getClientOriginalName());
  884.         $extension = $nameSplitByDot && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
  885.         $type = preg_replace('/\/[a-zA-Z-_,.]*\s?/',"",$file->getMimeType());
  886.         $nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
  887.         $newFilename = 'audio-' . uniqid() . '.' . $extension;
  888.         $this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
  889.         $fileMessage = new FileMessage();
  890.         $fileMessage->setName($newFilename);
  891.         $fileMessage->setIsNew(1);
  892.         $fileMessage->setIsNotInfected(true);
  893.         $fileMessage->setType($type);
  894.         $message->addFileMessage($fileMessage);
  895.         $message->setUser($this->getUser())
  896.             ->setCampaign($mission->getCampaign())
  897.             ->setMission(mission: $mission)
  898.             ->setUserListWhoRead([$this->getUser()->getId()]);
  899.         if (!is_null($group)) {
  900.             $message->setDiscussionGroup($group);
  901.         }
  902.         $entityManager->persist($message);
  903.         $entityManager->flush();
  904.         $this->chatService->publishMessageNotificationCampaign($mission->getId(),[
  905.                 'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
  906.                 'html'=>$this->getHtmlToRenderInViewForLastMessage($mission,$message,$dateOffSetHour),'type'=>'insert'],$group);
  907.         return new JsonResponse('ok');
  909.     }
  912.     #[Route('/planning/validation/{type}/{id}/{stepId}', name: '_planning_validation', methods: ['GET'])]
  913.     public function stepValidation(string $type, string $stepId, WorkflowStepRepository $workflowStepRepository, Mission $mission)
  914.     {
  916.         return new JsonResponse([
  917.             'html' => $this->getHtmlValidationStep($type, $mission, $workflowStepRepository->findOneBy(['id' => $stepId]))
  918.         ]);
  919.     }
  920.       private function getHtmlValidationStep(string $type, Mission $mission, WorkflowStep $step)
  921.     {
  923.         return $this->twig->render('mission/_validation_step.html.twig', [
  924.             'type' => $type,
  925.             'mission' => $mission,
  926.             'step' => $step,
  927.             'requirementForClosed' => $this->campaignService->getRequirementToResendOrderToClient($mission->getCampaign())
  928.         ]);
  929.     }
  930.     private function getHtmlToRenderInView(?Mission $mission, array $listLastMessage, string $timeZone, float $dateOffSetHour, bool|null $unredMessage = false,int $nbAllMessage =0,$group = null)
  931.     {
  932.         if (sizeof($listLastMessage) == 0) {
  933.             return "";
  934.         }
  935.         $listLastMessageNoDuble = [];
  936.         $seenMessages = [];
  938.         foreach ($listLastMessage as $message) {
  939.             if ($message->getContent() != null) {
  940.                 $uniqueKey = $message->getContent() . '_' . $message->getCreatedAt()->format('Y-m-d H:i');
  941.                 if (!isset($seenMessages[$uniqueKey])) {
  942.                     $listLastMessageNoDuble[] = $message;
  943.                     $seenMessages[$uniqueKey] = true;
  944.                 }
  945.             }else{
  946.                  $listLastMessageNoDuble[] = $message;
  947.             }
  948.         }
  950.         return $this->twig->render("mission/_chat_item.html.twig", [
  951.             "messages" => $listLastMessage,
  952.             "nbAllMessage" => $nbAllMessage,
  953.             "mission" => $mission,
  954.             "unred_message" => $unredMessage,
  955.             "time_zone" => $timeZone,
  956.             "date_off_setHour" => abs($dateOffSetHour),
  957.             "group" => $group,
  958.             "currentUser" => $this->getUser()
  959.         ]);
  960.     }
  962.      private function getHtmlToRenderInViewForLastMessage(?Mission $mission,$message,$dateOffSetHour)
  963.     {
  964.        
  965.         return $this->twig->render("mission/_chat_by_item.html.twig", [
  966.             "message" => $message,
  967.             "mission" => $mission,
  968.             "date_off_setHour" => abs($dateOffSetHour),
  969.             "currentUser" => $this->getUser()
  970.         ]);
  971.     }
  974.     private function getHtmlFutureActions (Mission $mission, array $futuresActions, ?string $currentRouteName=null, ?string $estimatedIncome=null)
  975.     {   
  976.         $formMissionInitialTimeManually = $this->createForm(MissionParticipantDelaisType::class);
  977.         return $this->twig->render("mission/Ux/_futures_actions.html.twig", [
  978.             'futurActions'=> $futuresActions, 
  979.             'mission'=> $mission,
  980.             'price_service' => $this->priceService,
  981.             'campaign'=> $mission->getCampaign(),
  982.             'currentRouteName'=>$currentRouteName,
  983.             'estimatedIncome'=> $this->getEstimatedIncome(),
  984.             'formMissionInitialTimeManually' => $formMissionInitialTimeManually->createView(),
  985.         ]);
  986.     }
  988.     private function getEstimatedIncome(){
  989.         if ($this->isGranted(Role::ROLE_ADMIN->value)) {
  990.             $priceCampaign = $this->missionParticipantRepository->findByInitialTime();
  991.             $estimatedIncome = [];
  992.             $initialTime = [];
  993.             $price = [];
  994.             foreach ($priceCampaign as $value) {
  995.                 if (!isset($estimatedIncome[$value->getMission()->getId()])) {
  996.                     $estimatedIncome[$value->getMission()->getId()] = [];
  997.                 }
  998.                 $initialTime[$value->getMission()->getId()][] = $value->getInitialTime();
  999.                 $price[$value->getMission()->getId()][] = $value->getEstimatedIncome();
  1000.             }
  1001.         } elseif ($this->isGranted(Role::ROLE_SUBCONTRACTOR->value)) {
  1002.             $visibleCampaign = ['orderedBy' => $this->getUser()];
  1003.             $estimatedIncome = $this->missionParticipantRepository->getSubcontractorForUserAndMission($this->getUser());
  1004.         } else {
  1005.             $estimatedIncome = null;
  1006.         }
  1007.         return $estimatedIncome;
  1008.     }
  1009.     private function getIdsMessage(array $listLastMessage){
  1010.         $ids = []; 
  1011.         $fileIds = []; 
  1012.         foreach ($listLastMessage as $key => $message) {
  1013.             $ids =[...$ids, $message->getId()]; 
  1014.             foreach ($message->getFileMessages() as $fileMessage) {
  1015.                 $fileIds =[...$fileIds, $fileMessage->getId()]; 
  1016.             }
  1017.         }
  1020.         return [
  1021.             'message_ids'=>$ids, 
  1022.             'file_message_ids'=> $fileIds
  1023.         ]; 
  1024.     }
  1025.     private function  getUserTypingMessage(array $user_typing){
  1026.         return $this->twig->render('services/messages/user_typing_message.html.twig',[
  1027.             'user_typing' => $user_typing
  1028.         ]);
  1029.     }
  1031.     private function getElementReactions(array $messages){
  1032.         $listMessageWithReactions = []; 
  1034.         foreach ($messages as $key => $message) {
  1035.             $listMessageWithReactions = [... $listMessageWithReactions,[
  1036.                  'id'=> $message->getId(), 
  1037.                  'content'=> $this->messageService->getReactionsHtml($message)
  1038.             ]];
  1039.         }
  1040.         return $listMessageWithReactions ; 
  1041.     }
  1042.     private function userReadLastMessage(?Message $message=null,$group = null){
  1044.         $userIds = [];
  1045.         $users = []; 
  1047.         if($message!=null){
  1048.             foreach ($message->getUserListWhoRead() as $userRead) {
  1049.                 if ($userRead instanceof User) {
  1050.                     $userIds[] = ($userRead->getId());
  1051.                 }else{
  1052.                     $userIds[] = $userRead;
  1053.                 }
  1054.             }
  1055.             //dd($userIds,[$message->getUser()->getId()]);
  1056.             $userIds = array_diff($userIds, [$message->getUser()->getId()]);
  1057.             $users = $this->userRepository->findByIds($userIds);
  1058.         }
  1060.         return [
  1061.                     'html'=>$this->twig->render('services/messages/users_who_read.html.twig',[
  1062.                                 'user_list' => $users,
  1063.                                 'group' => $group
  1064.                     ]), 
  1065.                     'ids'=>[...$userIds], 
  1066.             ]
  1067.         
  1068.        ;
  1069.     }
  1071.     function splitChar($string, $lg_max)
  1072.     {
  1073.         if (strlen($string) > $lg_max) {
  1074.             $string = substr($string, 0, $lg_max);
  1075.             $last_space = strrpos($string, " ");
  1076.             $string = substr($string, 0, $last_space) . "...";
  1078.         }
  1079.         return $string;
  1080.     }
  1082.     #[Route('/user/istyping/{id}/{idUser}',name:'user_is_typing')]
  1083.     public function setUserIsTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1084.         
  1085.         $groupId = $request->query->get('groupId');
  1086.         $group = null;
  1087.         if (!empty($groupId) && !is_null($groupId)) {
  1088.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1089.         }
  1090.         //envoyer donnez sur mercure
  1091.         $entityManager = $this->getDoctrine()->getManager();
  1092.         $campaign = $entityManager->getRepository(Campaign::class)->find($id);
  1093.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1094.         $this->chatService->publishMessageNotificationCampaign($campaign->getMissions()->first()->getId(),[
  1095.                 'message'=>"",
  1096.                 'type'=>'isTyping',
  1097.                 'currentUser' => $user->getId(),
  1098.                 'missionIds'=>array_map(function($item){
  1099.                     return  $item->getId(); 
  1100.                  }, $campaign->getMissions()->toArray()),
  1101.                 'typingRender' => $this->chatService->userTyping($user),
  1102.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1103.             ],$group);
  1104.         //fin envoie
  1105.         return new JsonResponse([
  1106.             'status'=>'ok',
  1107.         ]);
  1108.     }
  1110.     #[Route('/user/isStopTyping/{id}/{idUser}',name:'user_is_stop_typing')]
  1111.     public function setUserIsStopTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
  1112.         $groupId = $request->query->get('groupId');
  1113.         $group = null;
  1114.         if (!empty($groupId) && !is_null($groupId)) {
  1115.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1116.         }
  1117.         //envoyer donnez sur mercure
  1118.         $entityManager = $this->getDoctrine()->getManager();
  1119.         $mission = $entityManager->getRepository(Mission::class)->find($id);
  1120.         $user = $entityManager->getRepository(User::class)->find($idUser);
  1121.         $this->chatService->publishMessageNotificationCampaign($mission->getId(),[
  1122.                 'message'=>"",
  1123.                 'type'=>'isStopTyping',
  1124.                 'currentUser' => $user->getId(),
  1125.                 'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
  1126.             ],$group);
  1127.         //fin envoie
  1128.         return new JsonResponse([
  1129.             'status'=>'ok',
  1130.         ]);
  1131.     }
  1133.     #[Route('/pinned/{id}',name:'pinned_message')]
  1134.     public function pinned(Message $message,CampaignRepository $campaignRepository,Request $request){
  1135.         $idCurrentUser = $request->query->get('idCurrentUser');
  1136.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1137.         $message->setInsertPinned(new \DateTime())->addPinnedByUser($user);
  1138.         $this->entityManagerInterface->persist($message);
  1139.         $this->entityManagerInterface->flush();
  1140.         $dateOffSetHour = floatval($request->query->get('date-offset-hour'));
  1141.         $groupId = $request->query->get('groupId');
  1143.         $group = null;
  1144.         if (!empty($groupId) && !is_null($groupId)) {
  1145.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1146.         }
  1147.         //faut prendre les rendu du pinned
  1148.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1149.         //         'message'=>$message->getId(),
  1150.         //         'type'=>'isPinned',
  1151.         //         'currentUser' => $user->getId(),
  1152.         //         'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser())
  1153.         //     ],$group);
  1154.         //fin envoie
  1155.         return new JsonResponse([
  1156.             'status'=>'ok',
  1157.             'message'=>$message->getId(),
  1158.             'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser(),$dateOffSetHour)
  1159.         ]);
  1160.     }
  1162.     #[Route('/pinned-off/{id}',name:'pinned_message_off')]
  1163.     public function pinnedOff(Message $message,CampaignRepository $campaignRepository,Request $request){
  1164.         $idCurrentUser = $request->query->get('idCurrentUser');
  1165.         $user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
  1166.         $message->removePinnedByUser($user);
  1167.         $this->entityManagerInterface->persist($message);
  1168.         $this->entityManagerInterface->flush();
  1170.         $groupId = $request->query->get('groupId');
  1172.         $group = null;
  1173.         if (!empty($groupId) && !is_null($groupId)) {
  1174.             $group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
  1175.         }
  1176.         // //faut prendre les rendu du pinned
  1177.         // $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
  1178.         //     'message'=>$message->getId(),
  1179.         //     'type'=>'isPinnedOff',
  1180.         // ],$group);
  1181.         //fin envoie
  1182.         return new JsonResponse([
  1183.             'status'=>'ok',
  1184.             'message'=>$message->getId(),
  1185.         ]);
  1186.     }
  1188.     
  1191.  
  1192. }