<?php
namespace App\Controller;
use App\Entity\FileMessage;
use App\Entity\Message;
use App\Entity\User;
use App\Entity\MessageReaction;
use App\Entity\DiscussionGroup;
use Symfony\Component\Uid\Uuid;
use App\Entity\GroupMessage;
use App\Entity\Mission;
use App\Entity\WorkflowStep;
use App\Form\GroupMessageType;
use App\Entity\Campaign;
use App\Enum\AdminMail;
use App\Enum\Role;
use App\Event\User\UserReactionEvent;
use Symfony\Component\Serializer\SerializerInterface;
use App\Form\MessageType;
use App\Form\MissionParticipantDelaisType;
use App\Repository\MessageReactionRepository;
use App\Repository\MessageRepository;
use App\Repository\MissionRepository;
use App\Repository\UserRepository;
use App\Repository\WorkflowStepRepository;
use App\Repository\CampaignRepository;
use App\Repository\FileMessageRepository;
use App\Repository\MissionParticipantRepository;
use App\Service\MessageService;
use App\Service\NotificationService;
use Doctrine\ORM\EntityManagerInterface;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Mime\Address;
use Twig\Environment;
use App\Service\GoogleStorageService;
use App\Service\MissionParticipantService;
use App\Service\PriceService;
use App\Service\ChatService;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
use App\EventSubscriber\GroupeMessageSubscriber;
use App\Event\Chat\GroupedMessageSentEvent;
#[Route('/messages', name: 'messages')]
class SycMessagesAndPlanning extends AbstractController
{
public function __construct(
private Environment $twig,
private EntityManagerInterface $entityManagerInterface,
private Filesystem $filesystem,
private MessageService $messageService,
private LoggerInterface $logger,
private MessageRepository $messageRepository,
private MessageReactionRepository $messageReactionRepository,
private EventDispatcherInterface $dispatcher,
private NotificationService $notificationService,
private MissionParticipantService $missionParticipantService,
private UserRepository $userRepository,
private GoogleStorageService $googleStorageService,
private MissionParticipantRepository $missionParticipantRepository,
private PriceService $priceService,
private ChatService $chatService,
private SerializerInterface $serializer,
) {
}
#[Route('/update/user-who-read/{lastIdMessage}', name: 'user_who_read')]
public function userWhoReadUpdate(Request $request,FileMessageRepository $fileMessageRepository, MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository)
{
$lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
$message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
$groupMessageId = $request->query->get('group-message-id');
$missionId = $request->query->get('mission-id');
$mission = $missionRepository->findOneBy(["id" => $missionId]);
$group = null;
if (null !== $groupMessageId) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
}
$this->chatService->publishMessageNotificationCampaign(
$mission->getId(),
[
'message' => [],
'html' => "",
'type' => 'insert',
'planning' => "",
'currentUser' => $this->getUser()->getId(),
],
$group
);
return new JsonResponse([
'status' => "ok",
]);
}
#[Route('/last/{lastIdMessage}-{nbMessage}', name: 'last')]
public function lastMessages(Request $request,FileMessageRepository $fileMessageRepository, MissionRepository $missionRepository, string $lastIdMessage, MessageRepository $messageRepository,UserRepository $userRepository, $nbMessage = 10)
{
if ($this->getUser() == null) {
return new JsonResponse([
'status' => "KO",
], Response::HTTP_UNAUTHORIZED);
}
$unredMessage = $request->query->get('unred-message');
$missionId = $request->query->get('mission-id');
$currentRouteName=$request->query->get('current-route-name');
$estimatedIncome = $request->query->get('estimatedIncome');
$timeZone = $request->query->get('time-zone');
$groupMessageId = $request->query->get('group-message-id');
$group = null;
if (null !== $groupMessageId) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupMessageId);
}
$dateOffSetHour = floatval($request->query->get('date-offset-hour'));
$isLoadMore = $request->query->get('is-load-more');
$lastIdMessage = preg_replace("/message/", "", $lastIdMessage);
$messageIdsDeleted = [] ;
$fileMessageIdsDeleted = [];
$messagesEditing = [];
$messagesWithReactions = [];
$mission = $missionRepository->findOneBy(["id" => $missionId]);
$listOfUserTyping = $this->messageService->getUserTypingWithoutCurrentUser($mission);
$userTypingWithDuration = $this->messageService->calculaTimeTypingOfEachUser($listOfUserTyping);
if(is_null($userTypingWithDuration)){
$userTypingWithDuration = [];
}
$message = $messageRepository->findOneBy(['id' => $lastIdMessage]);
if ($mission != null) {
if($isLoadMore == "true" || $message == null){
$listLastMessage = $messageRepository->getAllMessage($mission->getCampaign(),$nbMessage,$group);
//dd($listLastMessage,$group);
}
else{
$listLastMessage =$messageRepository->findLastMessage($mission->getCampaign(), $message->getCreatedAt(),$group);
$messageIdsDeleted = $messageRepository->findIdsMessageDeleted($mission->getCampaign(),$group) ;
$fileMessageIdsDeleted = $fileMessageRepository->findIdsFileMessageDeleted($mission->getCampaign());
$messagesEditing= $messageRepository->findMessagesEditing($mission->getCampaign(),$group) ;
$messagesWithReactions= $messageRepository->findMessageWithReaction($mission->getCampaign(),$group) ;
}
$nbAllMessage = $messageRepository->nbAllMessage($mission->getCampaign(),$group)['nb'];
usort($listLastMessage, function($a, $b) {
$dateA = ($a->getCreatedAt()->getTimestamp());
$dateB = ($b->getCreatedAt()->getTimestamp());
return $dateA - $dateB ;
});
$missionParticipant = null;
foreach ($mission->getParticipants() as $participant) {
if ($participant->getUser()->getId() == $this->getUser()->getId()) {
$missionParticipant = $participant;
}
}
$lastTenMessages = $messageRepository->getLastTenMessages($mission->getCampaign(),$group);
$listIdsLastMessage = $this->getIdsMessage($lastTenMessages);
$futuresActions = $this->missionParticipantService->getUniqByFutureActions($mission->getCampaign()->getId(),$this->getUser()->getId());
return new JsonResponse([
"status" => "ok",
"html" => $this->getHtmlToRenderInView(mission: $mission, listLastMessage: $listLastMessage, timeZone: $timeZone, dateOffSetHour: $dateOffSetHour, unredMessage: $unredMessage,nbAllMessage: $nbAllMessage,group:$group),
"lists_last_message_id"=>$listIdsLastMessage['message_ids'],
"lists_last_file_message_id"=>$listIdsLastMessage['file_message_ids'],
"planning" => $this->twig->render("mission/_planning_item.html.twig", [
"mission" => $mission,
"campaign" => $mission->getCampaign(),
"userConnected" => $this->getUser(),
"missionParticipant" => $missionParticipant,
]),
"list_user_read_last_message"=>$this->userReadLastMessage($messageRepository->findOneBy(['campaign' => $mission->getCampaign()], ['createdAt' => 'DESC'])),
"message_deleted_ids"=> $messageIdsDeleted,
'user_typing' => $this->getUserTypingMessage($userTypingWithDuration),
"file_message_deleted_ids"=> $fileMessageIdsDeleted,
"messages_editing"=>$messagesEditing,
"messages_with_reactions"=>$this->getElementReactions($messagesWithReactions),
"futureActions" => $this->getHtmlFutureActions($mission, $futuresActions, $currentRouteName, $estimatedIncome),
]);
}
// $this->sendEmailError('-', '-', 'L\'id de la mission est null');
return new JsonResponse(["status" => "ko"], 200);
}
#[Route('/delete/{id}', name: 'detele_message', methods: ['POST'])]
public function deleteMessages(Message $message,Request $request)
{
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
if ($message->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
$message->setIsDeleted(true);
$this->entityManagerInterface->flush();
//ecoute de suppression
$this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
//fin ecoute
$this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
"message" => "",
'idMission' => $message->getMission()->getId(),
'group' => !is_null($group) ? $group->getId() : "",
'type' => 'message-unread'
]);
return new JsonResponse([
'status' => "ok"
]);
}
return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
}
#[Route('/delete/file/{id}', name: 'detele_file_message', methods: ['POST'])]
public function deleteFileMessages(FileMessage $fileMessage, GoogleStorageService $googleStorageService,Request $request)
{
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
if ($fileMessage->getMessages()->getUser()->getId() == $this->getUser()->getId() || $this->isGranted('ROLE_ADMIN')) {
$message = $fileMessage->getMessages();
//delete file if in storage
$company = $message->getCampaign()->getCompany();
$campaign = $message->getCampaign();
$bucketName = "company-" . strtolower($company->getId());
$fileName = "Campaigns/" . $campaign->getId() . "/" . $fileMessage->getName();
//end delete in google storage
$fileMessage->setIsDeleted(true);
$this->entityManagerInterface->flush();
$file = $this->messageService->getFileMissionUrl($fileMessage->getMessages()->getMission(), $fileMessage->getName());
if ($message->getContent() == null && $fileMessage->getMessages()->getFileMessages()!=null && $this->messageService->allFileMessageIsDeleted($fileMessage->getMessages())) {
$message->setIsDeleted(true);
$this->entityManagerInterface->flush();
}
try {
$this->filesystem->remove($file);
} catch (\Throwable $th) {
$this->logger->error("can't delete file in $file");
}
$googleStorageService->deleteFile($bucketName, $fileName);
//ecoute de suppression fichier message
$this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),['message'=>$message->getId(),'type'=>'deleted'],$group);
$this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
"message" => "",
'idMission' => $campaign->getMissions()->first()->getId(),
'group' => !is_null($group) ? $group->getId() : "",
'type' => 'message-unread'
]);
//fin ecoute
return new JsonResponse([
'status' => "ok"
]);
}
return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
}
#[Route('/emoji/toggle/{id}', name: 'toggle_emoji_reaction', methods: ['POST', 'GET'])]
public function toggleEmojiReaction(Message $message, Request $request): JsonResponse
{
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
$user = $this->getUser();
if ($user != null) {
$emoji = $request->request->get('emoji');
$emojiId = $request->request->get('emojiId');
$campaignOfMessage = $message->getCampaign();
$messageReaction = $this->messageReactionRepository->findReactionByUser(messageId: $message->getId(), userId: $user->getId(), emojiId: $emojiId);
if ($messageReaction != null) {
$message->removeMessageReaction($messageReaction[0]);
$this->entityManagerInterface->remove($messageReaction[0]);
$this->entityManagerInterface->flush();
} else {
$newReaction = new MessageReaction();
$newReaction->setEmoji($emoji);
$newReaction->setUser($user);
$newReaction->setEmojiId(intval($emojiId));
$newReaction->setMessage($message);
$message->addMessageReaction($newReaction);
$this->entityManagerInterface->persist($newReaction);
$this->entityManagerInterface->flush();
$event = new UserReactionEvent($message->getUser(), $this->getUser(), $message, $newReaction->getEmoji(),$campaignOfMessage);
$this->dispatcher->dispatch($event, UserReactionEvent::NAME);
}
$mission = $message->getMission();
$renderContent = $this->chatService->getHtmlContentToRenderInViewForLastMessage($mission,$message,0);
$this->chatService->publishMessageNotificationCampaign(
$mission->getId(),
[
'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
'html'=>$renderContent,
'type'=>'update',
],$group);
return new JsonResponse([
'status' => "ok",
'id_user' => $user->getId()
]);
}
return new JsonResponse(['status' => "ko", Response::HTTP_UNAUTHORIZED]);
}
#[Route('/send/error', name: 'send_error', methods: ['POST'])]
public function sendError(Request $request)
{
$this->messageService->sendEmailError($request->request->get('xhr'), $request->request->get('type'), $request->request->get('message'));
return new JsonResponse([]);
}
#[Route('/get/user/who/read/{id}', name: '_get_message_user_who_read', methods: ['GET'])]
public function whoRead(Message $message, Request $request, MessageRepository $messageRepository)
{
$userIdsread = $this->messageService->getBullUsersWhoReadMessage($message);
$userIdsData = [];
foreach ($userIdsread as $user) {
$userIdsData[] = $user->getId();
}
return new JsonResponse([
'status' => 'ok',
'userWhoReadIds' => $userIdsData,
"messageId" => $message->getId(),
'userId' => $request->query->get('currentUserId'),
'renderUserWhoRead' => $this->chatService->userWhoRead($message)
]);
}
#[Route('/get/message/by/user/{idUser}/{idMessage}/{dateOffsetHour}', name: '_get_message_for_user_by_id', methods: ['GET'])]
public function getMessageByUser($idUser, $idMessage,$dateOffsetHour, Request $request, MessageRepository $messageRepository)
{
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
$entityManager = $this->getDoctrine()->getManager();
$user = $entityManager->getRepository(User::class)->find($idUser);
$dateOffSetHour = floatval($request->query->get('date-offset-hour'));
$entityManager->flush();
$message = $entityManager->getRepository(Message::class)->find($idMessage);
$listUserWhoRead = $message->getUserListWhoRead();
$listUserWhoRead[] = $user->getId();
$message->setUserListWhoRead($listUserWhoRead);
$entityManager = $this->getDoctrine()->getManager();
$entityManager->persist($message);
$entityManager->flush();
$html = $this->twig->render("mission/_chat_by_item_for_listener.html.twig", [
"message" => $message,
"mission" => $message->getMission(),
"date_off_setHour" => abs($dateOffsetHour),
"user" => $user
]);
//mise a jour bloc user who read
$this->chatService->publishMessageNotificationCampaign(
$message->getCampaign()->getMissions()->first()->getId(),
[
'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
'type' => "userWhoRead",
'userId' => $user->getId(),
],
$group
);
//fin mise a jour
//end notification
return new JsonResponse([
'status' => 'ok',
'htmlRender'=> $html,
"message" => $message,
'planningRender' => $this->chatService->getHtmlToRenderPlanningByUser($user,$message->getMission()),
'renderUserWhoRead' => $this->chatService->userWhoRead($message)
]);
}
#[Route('/add_group/{id}', name: '_add_group', methods: ['POST'])]
public function addGroupedMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
{
$group = new DiscussionGroup();
$entityManager = $this->getDoctrine()->getManager();
$formCreatedGroup = $this->createForm(GroupMessageType::class, $group, ['listUser' => $mission->getCampaign()->getAllUserInCampaing()]);
$formCreatedGroup->handleRequest($request);
if ($formCreatedGroup->isSubmitted() && $formCreatedGroup->isValid()) {
$id = Uuid::v4()->toBase58();
$group = $formCreatedGroup->getData();
$group->setId($id);
$group->setCreatedBy($this->getUser());
$group->setCampaign($mission->getCampaign());
$entityManager = $this->getDoctrine()->getManager();
$group->addUser($this->getUser());
$entityManager->persist($group);
$entityManager->flush();
//envoyer des message au utilisateur du groupe
foreach ($group->getUsers() as $user) {
if ($this->getUser()->getId() != $user->getId()) {
$userInstance = $entityManager->getRepository(User::class)->find($user->getId());
$event = new GroupedMessageSentEvent($group,$userInstance);
$this->dispatcher->dispatch($event, GroupedMessageSentEvent::NAME);
}
}
//fin envoie de messag
$this->chatService->publishOnDiscussionGroupUpdate('add',$group);
$this->addFlash(
type: 'success',
message: "Groupe créé avec succès !",
);
//redirection vers la page list mission avec message de confirmation
return $this->redirectToRoute('mission_discussion_group', ['id' => $mission->getCampaign()->getMissions()?->first()?->getId(),'groupId'=>$group->getId()], Response::HTTP_SEE_OTHER);
}
$this->addFlash(
type: 'error',
message: "Erreur lors de la création du groupe",
);
return $this->redirectToRoute('mission_edit', ['id' => $mission->getCampaign()->getMissionsWithoutEspaceDeDiscussion()?->first()?->getId()], Response::HTTP_SEE_OTHER);
}
#[Route('/add/{id}', name: '_add', methods: ['POST'])]
public function addMessage(Request $request, Mission $mission, MessageRepository $messageRepository)
{
$message = new Message();
$typeMessage = "insert";
$entityManager = $this->getDoctrine()->getManager();
$path = 'file_message_directory';
$form = $this->createForm(MessageType::class, $message);
$form->handleRequest($request);
$error_id_message = $request->query->get('error_id_message', null);
$dateOffSetHour = floatval($request->query->get('date-offset-hour'));
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
}
$messageInsered = $messageRepository->findOneBy(['id' => $error_id_message]);
if ($form->isSubmitted() && $form->isValid() && $messageInsered == null or ($path = 'file_message_directory')) {
$errorMessage = "";
$errorCode = 200;
try {
$idMessage = $request->query->get('id-message');
$replyTo = $request->query->get('id-reply-message');
if ($idMessage != "") {
$typeMessage = "update";
$messagePersisted = $messageRepository->findOneBy(['id' => $idMessage]);
$messagePersisted->setIsModified(true);
$messagePersisted->setContent($message->getContent(), false);
$message = $messagePersisted;
} else {
$message->setUser($this->getUser())
->setCampaign($mission->getCampaign())
->setMission(mission: $mission)
->setUserListWhoRead([$this->getUser()->getId()])
->setOriginalContent($message->getContent());
;
if (!is_null($group)) {
$message->setDiscussionGroup($group);
}
$entityManager->persist($message);
}
if ($replyTo != "") {
$replyedMessage = $messageRepository->findOneBy(['id' => $replyTo]);
$message->setReplyToWithMessage($replyedMessage);
}
$entityManager->persist($message);
$entityManager->flush();
$this->messageService->sendEmailForParticipantMentionedInTchat($mission, $message);
// Publication des notifications
$renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
$timezone = new \DateTimeZone(date_default_timezone_get());
$utcCokkieInDays = $request->cookies->get('utcCokkieInDays');
if ($utcCokkieInDays) {
$offsetInHours = $utcCokkieInDays;
}else{
$offsetInHours = 0;
}
$this->chatService->publishMessageNotificationCampaign(
$mission->getId(),
[
'message' => $this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $message, $offsetInHours),
'type' => $typeMessage,
'planning' => $renderPlanning,
'currentUser' => $this->getUser()->getId(),
],
$group
);
$this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
"message" => "",
'idMission' => $mission->getId(),
'group' => !is_null($group) ? $group->getId() : "",
'type' => 'message-unread'
]);
$drapDrop = $request->query->get('drag-drop');
$files = !is_null($request->query->get('drag-drop')) && $request->query->get('drag-drop') == 1
? $request->files->get('file')
: $form->get('fileMessages')->getData();
// Vérification des fichiers
if (!empty($files) && sizeof($files) > 0) {
foreach ($files as $file) {
// Création d'un nouveau message pour chaque fichier
$newMessage = new Message();
$newMessage->setUser($this->getUser())
->setCampaign($mission->getCampaign())
->setMission($mission)
->setUserListWhoRead([$this->getUser()->getId()])
->setOriginalContent($message->getContent());
if (!is_null($group)) {
$newMessage->setDiscussionGroup($group);
}
// Traitement du fichier
$nameSplitByDot = explode('.', $file->getClientOriginalName());
$extension = $nameSplitByDot != null && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
$type = preg_replace('/\/[a-zA-Z-_,.]*\s?/', "", $file->getMimeType());
$nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
$destination = $this->getParameter($path) . '/' . $mission->getId() . '/message';
$originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
$newFilename = $originalFilename . '-' . uniqid() . '.' . $extension;
// Upload du fichier
$this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
// Création de l'objet FileMessage
$fileMessage = new FileMessage();
$fileMessage->setName($newFilename);
$fileMessage->setIsNew(1);
$fileMessage->setType($type);
$newMessage->addFileMessage($fileMessage);
// Persister le message
$entityManager->persist($newMessage);
// Notification par email pour les mentions dans le tchat
$this->messageService->sendEmailForParticipantMentionedInTchat($mission, $newMessage);
// Publication des notifications
$renderPlanning = $this->chatService->getHtmlToRenderPlanning($mission);
$this->chatService->publishMessageNotificationCampaign(
$mission->getId(),
[
'message' => $this->serializer->normalize($newMessage, null, [AbstractNormalizer::GROUPS => ['message_read']]),
'html' => $this->chatService->getHtmlToRenderInViewForLastMessage($mission, $newMessage, $offsetInHours),
'type' => $typeMessage,
'planning' => $renderPlanning,
'currentUser' => $this->getUser()->getId(),
],
$group
);
$this->chatService->publishNotificationMessageUnread("message-send-end-not-read", [
"message" => "",
'idMission' => $mission->getId(),
'group' => !is_null($group) ? $group->getId() : "",
'type' => 'message-unread'
]);
}
$entityManager->flush();
}else {
$errorMessage = "Empty content or no files provided.";
}
} catch (\Throwable $e) {
$errorMessage = "Throwable: " . $e->getMessage();
$errorCode = 500;
$this->messageService->sendEmailError('exception', $e->getMessage(), "message : {$message->getContent()} mission : {$mission->getId()}");
}
return new JsonResponse([
'status' => $errorMessage == "" ? 'ok' : 'ko',
'message_id' => $message->getId(),
'message' => $errorMessage == "" ? 'Enregistré avec succès' : $errorMessage,
], $errorCode);
}
return new JsonResponse([
'status' => 'ko',
'message_id' => $message->getId(),
'message' => 'Formulaire invalide',
], Response::HTTP_UNAUTHORIZED);
}
#[Route('/unread/{id}', name: '_unread', methods: ['POST','GET'])]
public function messageUnread(Request $request, Mission $mission, MessageRepository $messageRepository)
{
$entityManager = $this->getDoctrine()->getManager();
$groupId = $request->query->get('groupId');
$userId = $request->query->get('userId');
$group = null;
$user = $entityManager->getRepository(User::class)->find($userId);
if (!empty($groupId) && !is_null($groupId)) {
$group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
}
return new JsonResponse([
'status' => 'ko',
'missionId' => $mission->getId(),
'groupId' => $groupId,
'nombreUnread' => $this->messageService->getNumberMessageUnread(mission: $mission,groupedMessage : $group,user : $user)
]);
}
#[Route('/unread-all/{id}', name: '_unread_all', methods: ['POST','GET'])]
public function messageUnreadAll(Request $request, Mission $mission, MessageRepository $messageRepository)
{
$entityManager = $this->getDoctrine()->getManager();
$userId = $request->query->get('userId');
return new JsonResponse([
'status' => 'ok',
'missionId' => $mission->getId(),
'campaignId' => $mission->getCampaign()->getId(),
'nombreUnread' => $this->messageService->getNumberAllMessageUnread(mission: $mission,groupedMessage : null)
]);
}
#[Route('/addaudio/{id}', name: '_add_audio_file', methods: ['POST'])]
public function addAudioMessageFile(Mission $mission,Request $request, MessageRepository $messageRepository)
{
$message = new Message();
$dateOffSetHour = floatval($request->query->get('date-offset-hour'));
$entityManager = $this->getDoctrine()->getManager();
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $entityManager->getRepository(DiscussionGroup::class)->find($groupId);
}
$file = $request->files->get('audio');
$nameSplitByDot = explode('.', $file->getClientOriginalName());
$extension = $nameSplitByDot && sizeof($nameSplitByDot) > 1 ? end($nameSplitByDot) : $file->guessExtension();
$type = preg_replace('/\/[a-zA-Z-_,.]*\s?/',"",$file->getMimeType());
$nameUniqueCompany = strtolower("company-" . $mission->getCampaign()->getCompany()->getId());
$newFilename = 'audio-' . uniqid() . '.' . $extension;
$this->googleStorageService->uploadFile($nameUniqueCompany, $file, $newFilename, 'Campaigns/' . $mission->getCampaign()->getId());
$fileMessage = new FileMessage();
$fileMessage->setName($newFilename);
$fileMessage->setIsNew(1);
$fileMessage->setType($type);
$message->addFileMessage($fileMessage);
$message->setUser($this->getUser())
->setCampaign($mission->getCampaign())
->setMission(mission: $mission)
->setUserListWhoRead([$this->getUser()->getId()]);
if (!is_null($group)) {
$message->setDiscussionGroup($group);
}
$entityManager->persist($message);
$entityManager->flush();
$this->chatService->publishMessageNotificationCampaign($mission->getId(),[
'message'=>$this->serializer->normalize($message, null, [AbstractNormalizer::GROUPS => ['message_read']]),
'html'=>$this->getHtmlToRenderInViewForLastMessage($mission,$message,$dateOffSetHour),'type'=>'insert'],$group);
return new JsonResponse('ok');
}
#[Route('/planning/validation/{type}/{id}/{stepId}', name: '_planning_validation', methods: ['GET'])]
public function stepValidation(string $type, string $stepId, WorkflowStepRepository $workflowStepRepository, Mission $mission)
{
return new JsonResponse([
'html' => $this->getHtmlValidationStep($type, $mission, $workflowStepRepository->findOneBy(['id' => $stepId]))
]);
}
private function getHtmlValidationStep(string $type, Mission $mission, WorkflowStep $step)
{
return $this->twig->render('mission/_validation_step.html.twig', [
'type' => $type,
'mission' => $mission,
'step' => $step
]);
}
private function getHtmlToRenderInView(?Mission $mission, array $listLastMessage, string $timeZone, float $dateOffSetHour, bool|null $unredMessage = false,int $nbAllMessage =0,$group = null)
{
if (sizeof($listLastMessage) == 0) {
return "";
}
$listLastMessageNoDuble = [];
$seenMessages = [];
foreach ($listLastMessage as $message) {
if ($message->getContent() != null) {
$uniqueKey = $message->getContent() . '_' . $message->getCreatedAt()->format('Y-m-d H:i');
if (!isset($seenMessages[$uniqueKey])) {
$listLastMessageNoDuble[] = $message;
$seenMessages[$uniqueKey] = true;
}
}else{
$listLastMessageNoDuble[] = $message;
}
}
return $this->twig->render("mission/_chat_item.html.twig", [
"messages" => $listLastMessage,
"nbAllMessage" => $nbAllMessage,
"mission" => $mission,
"unred_message" => $unredMessage,
"time_zone" => $timeZone,
"date_off_setHour" => abs($dateOffSetHour),
"group" => $group,
"currentUser" => $this->getUser()
]);
}
private function getHtmlToRenderInViewForLastMessage(?Mission $mission,$message,$dateOffSetHour)
{
return $this->twig->render("mission/_chat_by_item.html.twig", [
"message" => $message,
"mission" => $mission,
"date_off_setHour" => abs($dateOffSetHour),
"currentUser" => $this->getUser()
]);
}
private function getHtmlFutureActions (Mission $mission, array $futuresActions, ?string $currentRouteName=null, ?string $estimatedIncome=null)
{
$formMissionInitialTimeManually = $this->createForm(MissionParticipantDelaisType::class);
return $this->twig->render("mission/Ux/_futures_actions.html.twig", [
'futurActions'=> $futuresActions,
'mission'=> $mission,
'price_service' => $this->priceService,
'campaign'=> $mission->getCampaign(),
'currentRouteName'=>$currentRouteName,
'estimatedIncome'=> $this->getEstimatedIncome(),
'formMissionInitialTimeManually' => $formMissionInitialTimeManually->createView(),
]);
}
private function getEstimatedIncome(){
if ($this->isGranted(Role::ROLE_ADMIN->value)) {
$priceCampaign = $this->missionParticipantRepository->findByInitialTime();
$estimatedIncome = [];
$initialTime = [];
$price = [];
foreach ($priceCampaign as $value) {
if (!isset($estimatedIncome[$value->getMission()->getId()])) {
$estimatedIncome[$value->getMission()->getId()] = [];
}
$initialTime[$value->getMission()->getId()][] = $value->getInitialTime();
$price[$value->getMission()->getId()][] = $value->getEstimatedIncome();
}
} elseif ($this->isGranted(Role::ROLE_SUBCONTRACTOR->value)) {
$visibleCampaign = ['orderedBy' => $this->getUser()];
$estimatedIncome = $this->missionParticipantRepository->getSubcontractorForUserAndMission($this->getUser());
} else {
$estimatedIncome = null;
}
return $estimatedIncome;
}
private function getIdsMessage(array $listLastMessage){
$ids = [];
$fileIds = [];
foreach ($listLastMessage as $key => $message) {
$ids =[...$ids, $message->getId()];
foreach ($message->getFileMessages() as $fileMessage) {
$fileIds =[...$fileIds, $fileMessage->getId()];
}
}
return [
'message_ids'=>$ids,
'file_message_ids'=> $fileIds
];
}
private function getUserTypingMessage(array $user_typing){
return $this->twig->render('services/messages/user_typing_message.html.twig',[
'user_typing' => $user_typing
]);
}
private function getElementReactions(array $messages){
$listMessageWithReactions = [];
foreach ($messages as $key => $message) {
$listMessageWithReactions = [... $listMessageWithReactions,[
'id'=> $message->getId(),
'content'=> $this->messageService->getReactionsHtml($message)
]];
}
return $listMessageWithReactions ;
}
private function userReadLastMessage(?Message $message=null){
$userIds = [];
$users = [];
if($message!=null){
$userIds = $message->getUserListWhoRead();
$userIds = array_diff($userIds, [$message->getUser()->getId()]);
$users = $this->userRepository->findByIds($userIds);
}
return [
'html'=>$this->twig->render('services/messages/users_who_read.html.twig',[
'user_list' => $users
]),
'ids'=>[...$userIds],
]
;
}
function splitChar($string, $lg_max)
{
if (strlen($string) > $lg_max) {
$string = substr($string, 0, $lg_max);
$last_space = strrpos($string, " ");
$string = substr($string, 0, $last_space) . "...";
}
return $string;
}
#[Route('/user/istyping/{id}/{idUser}',name:'user_is_typing')]
public function setUserIsTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
//envoyer donnez sur mercure
$entityManager = $this->getDoctrine()->getManager();
$campaign = $entityManager->getRepository(Campaign::class)->find($id);
$user = $entityManager->getRepository(User::class)->find($idUser);
$this->chatService->publishMessageNotificationCampaign($campaign->getMissions()->first()->getId(),[
'message'=>"",
'type'=>'isTyping',
'currentUser' => $user->getId(),
'typingRender' => $this->chatService->userTyping($user),
'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
],$group);
//fin envoie
return new JsonResponse([
'status'=>'ok',
]);
}
#[Route('/user/isStopTyping/{id}/{idUser}',name:'user_is_stop_typing')]
public function setUserIsStopTyping($id,$idUser,CampaignRepository $campaignRepository,Request $request){
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
//envoyer donnez sur mercure
$entityManager = $this->getDoctrine()->getManager();
$mission = $entityManager->getRepository(Mission::class)->find($id);
$user = $entityManager->getRepository(User::class)->find($idUser);
$this->chatService->publishMessageNotificationCampaign($mission->getId(),[
'message'=>"",
'type'=>'isStopTyping',
'currentUser' => $user->getId(),
'user'=> $this->serializer->normalize($user, null, [AbstractNormalizer::GROUPS => ['message_read']])
],$group);
//fin envoie
return new JsonResponse([
'status'=>'ok',
]);
}
#[Route('/pinned/{id}',name:'pinned_message')]
public function pinned(Message $message,CampaignRepository $campaignRepository,Request $request){
$idCurrentUser = $request->query->get('idCurrentUser');
$user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
$message->setInsertPinned(new \DateTime())->addPinnedByUser($user);
$this->entityManagerInterface->persist($message);
$this->entityManagerInterface->flush();
$dateOffSetHour = floatval($request->query->get('date-offset-hour'));
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
//faut prendre les rendu du pinned
// $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
// 'message'=>$message->getId(),
// 'type'=>'isPinned',
// 'currentUser' => $user->getId(),
// 'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser())
// ],$group);
//fin envoie
return new JsonResponse([
'status'=>'ok',
'message'=>$message->getId(),
'renderPinned'=> $this->chatService->messagePinned($message,$this->getUser(),$dateOffSetHour)
]);
}
#[Route('/pinned-off/{id}',name:'pinned_message_off')]
public function pinnedOff(Message $message,CampaignRepository $campaignRepository,Request $request){
$idCurrentUser = $request->query->get('idCurrentUser');
$user = $this->entityManagerInterface->getRepository(User::class)->find($idCurrentUser);
$message->removePinnedByUser($user);
$this->entityManagerInterface->persist($message);
$this->entityManagerInterface->flush();
$groupId = $request->query->get('groupId');
$group = null;
if (!empty($groupId) && !is_null($groupId)) {
$group = $this->entityManagerInterface->getRepository(DiscussionGroup::class)->find($groupId);
}
// //faut prendre les rendu du pinned
// $this->chatService->publishMessageNotificationCampaign($message->getMission()->getId(),[
// 'message'=>$message->getId(),
// 'type'=>'isPinnedOff',
// ],$group);
//fin envoie
return new JsonResponse([
'status'=>'ok',
'message'=>$message->getId(),
]);
}
}