src/Controller/NotificationController.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Notification;
  6. use App\Service\NotificationService;
  7. use Doctrine\ORM\EntityManagerInterface;
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Symfony\Component\HttpFoundation\JsonResponse;
  10. use Symfony\Component\HttpFoundation\Request;
  11. use Symfony\Component\HttpFoundation\Response;
  12. use Symfony\Component\Routing\Annotation\Route;
  14. class NotificationController extends AbstractController
  15. {
  16.     #[Route('/api/notifications/count', name: 'api_notifications_count', methods: ['GET'])]
  17.     public function count(NotificationService $notificationService): JsonResponse
  18.     {
  19.         if (!$this->getUser()) {
  20.             return $this->json(['count' => 0]);
  21.         }
  23.         $count = $notificationService->getUnreadCount($this->getUser());
  25.         return $this->json(['count' => $count]);
  26.     }
  28.     #[Route('/notifications', name: 'notifications_list')]
  29.     public function list(NotificationService $notificationService, EntityManagerInterface $entityManager, Request $request): Response
  30.     {
  31.         if (!$this->getUser()) {
  32.             return $this->redirectToRoute('ui_app_login');
  33.         }
  35.         $showArchived = $request->query->getBoolean('archived', false);
  36.         $type = $request->query->get('type', '');
  37.         $notifications = $notificationService->getUserNotifications($this->getUser(), 12, false, $showArchived, false, $type !== '' ? $type : null, 0);
  38.         $unreadCount = $notificationService->getUnreadCount($this->getUser());
  39.         
  40.         // Récupérer tous les types de notifications pour le sélecteur
  41.         $allTypes = $entityManager->getRepository(Notification::class)
  42.             ->createQueryBuilder('n')
  43.             ->select('DISTINCT n.type')
  44.             ->where('n.user = :user')
  45.             ->andWhere('n.isArchived = :archived')
  46.             ->andWhere('n.isDeleted = :deleted')
  47.             ->setParameter('user', $this->getUser())
  48.             ->setParameter('archived', $showArchived)
  49.             ->setParameter('deleted', false)
  50.             ->getQuery()
  51.             ->getResult();
  52.         
  53.         $types = array_filter(array_column($allTypes, 'type'));
  54.         
  55.         // Vérifier s'il y a des notifications sans type pour afficher l'option "non spécifié"
  56.         $hasNonSpecified = $entityManager->getRepository(Notification::class)
  57.             ->createQueryBuilder('n')
  58.             ->select('COUNT(n.id)')
  59.             ->where('n.user = :user')
  60.             ->andWhere('(n.type IS NULL OR n.type = :emptyType)')
  61.             ->andWhere('n.isArchived = :archived')
  62.             ->andWhere('n.isDeleted = :deleted')
  63.             ->setParameter('user', $this->getUser())
  64.             ->setParameter('emptyType', '')
  65.             ->setParameter('archived', $showArchived)
  66.             ->setParameter('deleted', false)
  67.             ->getQuery()
  68.             ->getSingleScalarResult() > 0;
  70.         return $this->render('account/notifications.html.twig', [
  71.             'notifications' => $notifications,
  72.             'unreadCount' => $unreadCount,
  73.             'showArchived' => $showArchived,
  74.             'selectedType' => $type,
  75.             'availableTypes' => $types,
  76.             'hasNonSpecified' => $hasNonSpecified,
  77.         ]);
  78.     }
  80.     #[Route('/api/notifications', name: 'api_notifications_list', methods: ['GET'])]
  81.     public function getNotifications(NotificationService $notificationService, Request $request): JsonResponse
  82.     {
  83.         if (!$this->getUser()) {
  84.             return $this->json(['error' => 'Non autorisé'], 401);
  85.         }
  87.         $limit = (int) $request->query->get('limit', 12);
  88.         $offset = (int) $request->query->get('offset', 0);
  89.         $unreadOnly = $request->query->getBoolean('unread_only', false);
  90.         $showArchived = $request->query->getBoolean('archived', false);
  91.         $type = $request->query->get('type', '');
  93.         $notifications = $notificationService->getUserNotifications(
  94.             $this->getUser(), 
  95.             $limit, 
  96.             $unreadOnly, 
  97.             $showArchived, 
  98.             false, 
  99.             $type !== '' ? $type : null,
  100.             $offset
  101.         );
  103.         $data = [];
  104.         foreach ($notifications as $notification) {
  105.             $data[] = [
  106.                 'id' => $notification->getId(),
  107.                 'title' => $notification->getTitle(),
  108.                 'message' => $notification->getMessage(),
  109.                 'type' => $notification->getType(),
  110.                 'isRead' => $notification->isIsRead(),
  111.                 'priority' => $notification->getPriority(),
  112.                 'createdAt' => $notification->getCreatedAt()->format('Y-m-d H:i:s'),
  113.                 'readAt' => $notification->getReadAt()?->format('Y-m-d H:i:s'),
  114.                 'isArchived' => $notification->isIsArchived(),
  115.                 'archivedAt' => $notification->getArchivedAt()?->format('Y-m-d H:i:s'),
  116.             ];
  117.         }
  119.         return $this->json([
  120.             'notifications' => $data,
  121.             'hasMore' => count($notifications) === $limit,
  122.             'count' => count($data)
  123.         ]);
  124.     }
  126.     #[Route('/api/notifications/{id}/read', name: 'api_notification_read', methods: ['POST'])]
  127.     public function markAsRead(int $id, NotificationService $notificationService, EntityManagerInterface $em): JsonResponse
  128.     {
  129.         if (!$this->getUser()) {
  130.             return $this->json(['error' => 'Non autorisé'], 401);
  131.         }
  133.         $notification = $em->getRepository(Notification::class)->find($id);
  134.         
  135.         if (!$notification || $notification->getUser() !== $this->getUser()) {
  136.             return $this->json(['error' => 'Non autorisé'], 403);
  137.         }
  139.         $notificationService->markAsRead($notification);
  141.         return $this->json(['success' => true]);
  142.     }
  144.     #[Route('/api/notifications/read-all', name: 'api_notifications_read_all', methods: ['POST'])]
  145.     public function markAllAsRead(NotificationService $notificationService): JsonResponse
  146.     {
  147.         if (!$this->getUser()) {
  148.             return $this->json(['error' => 'Non autorisé'], 401);
  149.         }
  151.         $notificationService->markAllAsRead($this->getUser());
  153.         return $this->json(['success' => true]);
  154.     }
  156.     #[Route('/api/notifications/{id}/archive', name: 'api_notification_archive', methods: ['POST'])]
  157.     public function archiveNotification(int $id, NotificationService $notificationService, EntityManagerInterface $em): JsonResponse
  158.     {
  159.         if (!$this->getUser()) {
  160.             return $this->json(['error' => 'Non autorisé'], 401);
  161.         }
  163.         $notification = $em->getRepository(Notification::class)->find($id);
  164.         
  165.         if (!$notification || $notification->getUser() !== $this->getUser()) {
  166.             return $this->json(['error' => 'Non autorisé'], 403);
  167.         }
  169.         $notificationService->archiveNotification($notification);
  171.         return $this->json(['success' => true]);
  172.     }
  174.     #[Route('/api/notifications/{id}/delete', name: 'api_notification_delete', methods: ['POST'])]
  175.     public function deleteNotification(int $id, NotificationService $notificationService, EntityManagerInterface $em): JsonResponse
  176.     {
  177.         if (!$this->getUser()) {
  178.             return $this->json(['error' => 'Non autorisé'], 401);
  179.         }
  181.         $notification = $em->getRepository(Notification::class)->find($id);
  182.         
  183.         if (!$notification || $notification->getUser() !== $this->getUser()) {
  184.             return $this->json(['error' => 'Non autorisé'], 403);
  185.         }
  187.         $notificationService->deleteNotification($notification);
  189.         return $this->json(['success' => true]);
  190.     }
  191. }