src/Controller/ChatController.php line 219

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\ChatMessage;
  6. use App\Repository\ChatMessageRepository;
  7. use App\Repository\TeamRepository;
  8. use App\Repository\SeasonRepository;
  9. use App\Repository\UserRepository;
  10. use App\Service\ChatService;
  11. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\Routing\Annotation\Route;
  15. use Symfony\Component\Serializer\SerializerInterface;
  16. use Symfony\Component\Serializer\Annotation\Groups;
  18. class ChatController extends AbstractController
  19. {
  20.     public function __construct(
  21.         private ChatService $chatService,
  22.         private ChatMessageRepository $chatMessageRepository,
  23.         private TeamRepository $teamRepository,
  24.         private SeasonRepository $seasonRepository,
  25.         private UserRepository $userRepository,
  26.         private SerializerInterface $serializer
  27.     ) {}
  29.     #[Route('/api/chat/messages', name: 'api_chat_send_message', methods: ['POST'])]
  30.     public function sendMessage(Request $request): Response
  31.     {
  32.         $data = json_decode($request->getContent(), true);
  33.         
  34.         $content = $data['content'] ?? null;
  35.         $type = $data['type'] ?? null;
  36.         $attachmentUrl = $data['attachmentUrl'] ?? null;
  37.         
  38.         if (!$content || !$type) {
  39.             return $this->json(['error' => 'Missing required fields'], Response::HTTP_BAD_REQUEST);
  40.         }
  41.         
  42.         try {
  43.             $team = null;
  44.             $season = null;
  45.             $recipient = null;
  46.             
  47.             if ($type === 'team' && isset($data['teamId'])) {
  48.                 $team = $this->teamRepository->find($data['teamId']);
  49.                 if (!$team) {
  50.                     return $this->json(['error' => 'Team not found'], Response::HTTP_NOT_FOUND);
  51.                 }
  52.             } elseif ($type === 'season' && isset($data['seasonId'])) {
  53.                 $season = $this->seasonRepository->find($data['seasonId']);
  54.                 if (!$season) {
  55.                     return $this->json(['error' => 'Season not found'], Response::HTTP_NOT_FOUND);
  56.                 }
  57.             } elseif ($type === 'direct' && isset($data['recipientId'])) {
  58.                 $recipient = $this->userRepository->find($data['recipientId']);
  59.                 if (!$recipient) {
  60.                     return $this->json(['error' => 'Recipient not found'], Response::HTTP_NOT_FOUND);
  61.                 }
  62.             } elseif ($type === 'global') {
  63.                 // For global messages, team, season, and recipient remain null.
  64.                 // No specific ID is needed.
  65.             } else {
  66.                 // This handles cases where type is not 'team', 'season', 'direct', or 'global',
  67.                 // or if the required ID for those types is missing.
  68.                 return $this->json(['error' => 'Invalid chat type or missing/invalid ID for the given type'], Response::HTTP_BAD_REQUEST);
  69.             }
  70.             
  71.             $message = $this->chatService->sendMessage(
  72.                 $content,
  73.                 $type,
  74.                 $team,
  75.                 $season,
  76.                 $recipient,
  77.                 $attachmentUrl
  78.             );
  79.             
  80.             return $this->json($message, Response::HTTP_CREATED, [], ['groups' => 'chat_message']);
  81.         } catch (\Exception $e) {
  82.             return $this->json(['error' => $e->getMessage()], Response::HTTP_BAD_REQUEST);
  83.         }
  84.     }
  86.     #[Route('/api/chat/team/{id}', name: 'api_chat_team_messages', methods: ['GET'])]
  87.     public function getTeamMessages(int $id, Request $request): Response
  88.     {
  89.         $team = $this->teamRepository->find($id);
  90.         if (!$team) {
  91.             return $this->json(['error' => 'Team not found'], Response::HTTP_NOT_FOUND);
  92.         }
  93.         
  94.         $limit = $request->query->getInt('limit', 50);
  95.         $offset = $request->query->getInt('offset', 0);
  96.         
  97.         $messages = $this->chatService->getMessages('team', $team, $limit, $offset);
  98.         
  99.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  100.     }
  102.     #[Route('/api/chat/season/{id}', name: 'api_chat_season_messages', methods: ['GET'])]
  103.     public function getSeasonMessages(int $id, Request $request): Response
  104.     {
  105.         $season = $this->seasonRepository->find($id);
  106.         if (!$season) {
  107.             return $this->json(['error' => 'Season not found'], Response::HTTP_NOT_FOUND);
  108.         }
  109.         
  110.         $limit = $request->query->getInt('limit', 50);
  111.         $offset = $request->query->getInt('offset', 0);
  112.         
  113.         $messages = $this->chatService->getMessages('season', $season, $limit, $offset);
  114.         
  115.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  116.     }
  118.     #[Route('/api/chat/direct/{id}', name: 'api_chat_direct_messages', methods: ['GET'])]
  119.     public function getDirectMessages(int $id, Request $request): Response
  120.     {
  121.         $recipient = $this->userRepository->find($id);
  122.         if (!$recipient) {
  123.             return $this->json(['error' => 'User not found'], Response::HTTP_NOT_FOUND);
  124.         }
  125.         
  126.         $limit = $request->query->getInt('limit', 50);
  127.         $offset = $request->query->getInt('offset', 0);
  128.         
  129.         $messages = $this->chatService->getMessages('direct', $recipient, $limit, $offset);
  130.         
  131.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  132.     }
  134.     #[Route('/api/chat/team/{id}/new', name: 'api_chat_new_team_messages', methods: ['GET'])]
  135.     public function getNewTeamMessages(int $id, Request $request): Response
  136.     {
  137.         $team = $this->teamRepository->find($id);
  138.         if (!$team) {
  139.             return $this->json(['error' => 'Team not found'], Response::HTTP_NOT_FOUND);
  140.         }
  141.         
  142.         $since = new \DateTime($request->query->get('since', 'now'));
  143.         
  144.         $messages = $this->chatService->getNewMessages('team', $team, $since);
  145.         
  146.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  147.     }
  149.     #[Route('/api/chat/season/{id}/new', name: 'api_chat_new_season_messages', methods: ['GET'])]
  150.     public function getNewSeasonMessages(int $id, Request $request): Response
  151.     {
  152.         $season = $this->seasonRepository->find($id);
  153.         if (!$season) {
  154.             return $this->json(['error' => 'Season not found'], Response::HTTP_NOT_FOUND);
  155.         }
  156.         
  157.         $since = new \DateTime($request->query->get('since', 'now'));
  158.         
  159.         $messages = $this->chatService->getNewMessages('season', $season, $since);
  160.         
  161.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  162.     }
  164.     #[Route('/api/chat/direct/{id}/new', name: 'api_chat_new_direct_messages', methods: ['GET'])]
  165.     public function getNewDirectMessages(int $id, Request $request): Response
  166.     {
  167.         $recipient = $this->userRepository->find($id);
  168.         if (!$recipient) {
  169.             return $this->json(['error' => 'User not found'], Response::HTTP_NOT_FOUND);
  170.         }
  171.         
  172.         $since = new \DateTime($request->query->get('since', 'now'));
  173.         
  174.         $messages = $this->chatService->getNewMessages('direct', $recipient, $since);
  175.         
  176.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  177.     }
  179.     #[Route('/api/chat/messages/{id}/read', name: 'api_chat_mark_read', methods: ['POST'])]
  180.     public function markAsRead(int $id): Response
  181.     {
  182.         $message = $this->chatMessageRepository->find($id);
  183.         if (!$message) {
  184.             return $this->json(['error' => 'Message not found'], Response::HTTP_NOT_FOUND);
  185.         }
  186.         
  187.         $this->chatService->markAsRead($message);
  188.         
  189.         return $this->json(['success' => true]);
  190.     }
  192.     #[Route('/api/chat/channels', name: 'api_chat_channels', methods: ['GET'])]
  193.     public function getChannels(): Response
  194.     {
  195.         $user = $this->getUser();
  196.         
  197.         // Get all channels the user has access to
  198.         $channels = $this->chatService->getAvailableChannels($user);
  199.         
  200.         // Use serialization groups to prevent circular references
  201.         return $this->json($channels, Response::HTTP_OK, [], ['groups' => 'chat:channel:list']);
  202.     }
  204.     #[Route('/api/chat/channels/{id}/messages', name: 'api_chat_channel_messages', methods: ['GET'])]
  205.     public function getChannelMessages(string $id, Request $request): Response
  206.     {
  207.         // Parse the channel ID to determine type and actual ID
  208.         list($type, $actualId) = $this->parseChannelId($id);
  209.         
  210.         $limit = $request->query->getInt('limit', 50);
  211.         $offset = $request->query->getInt('offset', 0);
  212.         
  213.         $messages = $this->chatService->getMessagesByChannel($type, $actualId, $limit, $offset);
  214.         
  215.         return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_message']);
  216.     }
  218.     #[Route('/api/chat/unread-counts', name: 'api_chat_unread_counts', methods: ['GET'])]
  219.     public function getUnreadCounts(): Response
  220.     {
  221.         $user = $this->getUser();
  222.         $counts = $this->chatService->getUnreadCountsByChannel($user);
  223.         
  224.         return $this->json($counts);
  225.     }
  227.     #[Route('/api/chat/channels/{id}/read', name: 'api_chat_mark_channel_read', methods: ['POST'])]
  228.     public function markChannelAsRead(string $id): Response
  229.     {
  230.         // Parse the channel ID to determine type and actual ID
  231.         list($type, $actualId) = $this->parseChannelId($id);
  232.         
  233.         $this->chatService->markChannelAsRead($type, $actualId);
  234.         
  235.         return $this->json(['success' => true]);
  236.     }
  238.     #[Route('/api/chat/widget-messages', name: 'api_chat_widget_messages', methods: ['GET'])]
  239.     public function getWidgetMessages(Request $request): Response
  240.     {
  241.         $user = $this->getUser();
  242.         if (!$user) {
  243.             return $this->json(['error' => 'User not authenticated'], Response::HTTP_UNAUTHORIZED);
  244.         }
  246.         // Consider a small limit for widget messages, e.g., 5 messages per channel, up to 3-5 channels
  247.         $limitPerChannel = $request->query->getInt('limit_per_channel', 3);
  248.         $maxChannels = $request->query->getInt('max_channels', 3);
  250.         try {
  251.             $messages = $this->chatService->getRecentMessagesForWidget($user, $limitPerChannel, $maxChannels);
  252.             // Ensure the response is structured as expected by ChatWidget.vue
  253.             // e.g., { "Channel Name 1": [msg1, msg2], "Channel Name 2": [msg3, msg4] }
  254.             return $this->json($messages, Response::HTTP_OK, [], ['groups' => 'chat_widget_message']); // Define a new serialization group if needed
  255.         } catch (\Exception $e) {
  256.             // Log the exception $e->getMessage()
  257.             return $this->json(['error' => 'Could not retrieve widget messages'], Response::HTTP_INTERNAL_SERVER_ERROR);
  258.         }
  259.     }
  261.     // Helper method to parse channel IDs
  262.     private function parseChannelId(string $id): array
  263.     {
  264.         if ($id === 'global') {
  265.             return ['global', null];
  266.         }
  267.         
  268.         $parts = explode('-', $id);
  269.         if (count($parts) !== 2) {
  270.             throw new \InvalidArgumentException('Invalid channel ID format');
  271.         }
  272.         
  273.         return [$parts[0], (int)$parts[1]];
  274.     }
  276.     #[Route('/chat', name: 'chat_index')]
  277.     public function index(): Response
  278.     {
  279.         return $this->render('chat/index.html.twig');
  280.     }
  282.     // Remove old chat routes
  283.     // #[Route('/chat/team/{id}', name: 'chat_team', methods: ['GET'])]
  284.     // ...
  285.     // #[Route('/chat/season/{id}', name: 'chat_season', methods: ['GET'])]
  286.     // ...
  287.     // #[Route('/chat/direct/{id}', name: 'chat_direct', methods: ['GET'])]
  288.     // ...
  289. }