src/Controller/MessageController.php line 199

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\MessagePatient;
  6. use App\Entity\Notification;
  7. use App\Entity\PaperPatient;
  8. use App\Entity\Patient;
  9. use App\Entity\User;
  10. use App\Form\MessagePatientType;
  11. use App\Form\PaperPatientType;
  12. use App\Repository\MessagePatientRepository;
  13. use Doctrine\ORM\EntityManagerInterface;
  14. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  15. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  16. use Symfony\Component\Cache\Adapter\FilesystemAdapter;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\Routing\Annotation\Route;
  20. use Symfony\Component\Security\Core\User\UserInterface;
  21. use Symfony\Component\Uid\Uuid;
  23. class MessageController extends AbstractController
  24. {
  25.     /**
  26.      * @Route("/message/professional/{id}", name="index_message_professional", methods={"GET","POST"})
  27.      * @IsGranted("ROLE_PROFESSIONAL")
  28.      */
  29.     public function index(?UserInterface $user, EntityManagerInterface $entityManager, Patient $patient, Request $request)
  30.     {
  32.         if (!$user) {
  33.             return $this->redirectToRoute('app_login');
  34.         }
  36.         $haveOffice = true;
  37.         if (!$user->getOffice()) {
  38.             $haveOffice = false;
  39.         }
  41.         $messagePatient = new MessagePatient();
  42.         $form = $this->createForm(MessagePatientType::class, $messagePatient);
  43.         $form->handleRequest($request);
  44.         if ($form->isSubmitted() && $form->isValid()) {
  45.             if ($user->getOffice() === $patient->getUser()->getOffice()) { //vérifie que le professionnel fasse parti du même cabinet que le patient cible
  47.                 $messagePatient->setAuthor($user);
  48.                 $messagePatient->setType(1);
  49.                 $messagePatient->setAffectedPatient($patient);
  51.                 $entityManager->persist($messagePatient);
  52.                 $entityManager->flush();
  53.                 $this->addFlash('info', "Nouveau message envoyé.");
  54.                 return $this->redirectToRoute('index_message_professional', ['id' => $patient->getId()]);
  55.             }
  56.         }
  58.         $messages = $entityManager->getRepository('App\Entity\MessagePatient')->findBy(['affectedPatient' => $patient], ['createdAt' => 'DESC']);
  60.         foreach ($messages as &$message) {
  61.             if ($message->getListProfessionalViewed() != null) {
  62.                 $listProfessional = explode(';', $message->getListProfessionalViewed());
  63.                 $message->setView(false);
  64.                 $fullName = [];
  65.                 foreach ($listProfessional as $professionalUuid) {
  66.                     $professional = $entityManager->getRepository('App\Entity\Professional')->find(Uuid::fromString($professionalUuid));
  68.                     if ($user->getIsProfessional()) {
  69.                         $userProfessional = $user->getProfessional();
  70.                         if ($professional == $userProfessional) {
  71.                             $message->setView(true);
  72.                         }
  73.                     }
  75.                     $fistName = $professional->getFirstName();
  76.                     $lastName = strtoupper($professional->getLastName()[0]);
  77.                     $fullName[] = $lastName . '.' . $fistName;
  79.                 }
  80.                 $message->setListProfessionalViewed(implode(', ', $fullName));
  81.             }
  82.         }
  84.         return $this->render('message/index.html.twig', [
  85.             'form' => $form->createView(),
  86.             'messages' => $messages,
  87.             'current_menu' => 'patient',
  88.             'patient' => $patient,
  89.             'haveOffice' => $haveOffice
  90.         ]);
  91.     }
  93.     /**
  94.      * @Route("/message/update/{idMessage}", name="message_update_view", options = { "expose" = true })
  95.      * définis un message comme vu
  96.      */
  97.     public function ajaxUpdateMessageView($idMessage, ?UserInterface $user, EntityManagerInterface $entityManager)
  98.     {
  100.         if (!$user) {
  101.             return $this->redirectToRoute('app_login');
  102.         }
  104.         $messagePatient = $entityManager->getRepository('App\Entity\MessagePatient')->find(json_decode($idMessage));
  106.         $patient = $messagePatient->getAffectedPatient();
  107.         $userOffice = $user->getOffice();
  109.         if ($userOffice === $patient->getUser()->getOffice() || $userOffice === $messagePatient->getAuthor()->getOffice()) {
  110.             if ($user->getIsProfessional()) {
  112.                 $professional = $user->getProfessional();
  113.                 $uuid = $professional->getId()->toRfc4122();
  114.                 $listProfessional = $messagePatient->getListProfessionalViewed();
  116.                 if ($listProfessional === null) {
  117.                     $listProfessional = [];
  118.                 } else {
  119.                     $listProfessional = explode(';', $listProfessional);
  120.                 }
  122.                 $listProfessional[] = $uuid;
  123.                 $listProfessional = implode(';', $listProfessional);
  125.                 $messagePatient->setListProfessionalViewed($listProfessional);
  127.             }
  128.             $messagePatient->setView(1);
  129.             $entityManager->persist($messagePatient);
  130.             $entityManager->flush();
  131.         }
  133.         return new JsonResponse([
  134.             'status' => 1,
  135.             'msg' => ''
  136.         ]);
  137.     }
  139.     /**
  140.      * @Route("/message/patient", name="index_message_patient", methods={"GET","POST"})
  141.      * @IsGranted("ROLE_PATIENT")
  142.      */
  143.     public function indexPatient(?UserInterface $user, EntityManagerInterface $entityManager, Request $request)
  144.     {
  145.         if (!$user) {
  146.             return $this->redirectToRoute('app_login');
  147.         }
  149.         $haveOffice = true;
  150.         if (!$user->getOffice()) {
  151.             $haveOffice = false;
  152.         }
  154.         $patient = $user->getPatient();
  156.         $messagePatient = new MessagePatient();
  157.         $form = $this->createForm(MessagePatientType::class, $messagePatient);
  158.         $form->handleRequest($request);
  160.         if ($form->isSubmitted() && $form->isValid()) {
  162.             //création d'une notification
  163.             $office = $user->getOffice();
  164.             $users = $entityManager->getRepository('App\Entity\User')->findBy(['office' => $office, 'isProfessional' => 1]);
  165.             foreach ($users as $oUser) {
  166.                 $notification = new Notification();
  167.                 $notification->setType(2);
  168.                 $notification->setUser($oUser);
  169.                 $entityManager->persist($notification);
  170.             }
  172.             $messagePatient->setAuthor($user);
  173.             $messagePatient->setType(2);
  174.             $messagePatient->setAffectedPatient($patient);
  176.             $entityManager->persist($messagePatient);
  177.             $entityManager->flush();
  178.             $this->addFlash('info', "Nouveau message envoyé.");
  180.             return $this->redirectToRoute('index_message_patient');
  182.         }
  184.         $messages = $entityManager->getRepository('App\Entity\MessagePatient')->findBy(['affectedPatient' => $patient], ['createdAt' => 'DESC']);
  186.         return $this->render('message/index.html.twig', [
  187.             'controller_name' => 'MessageController',
  188.             'form' => $form->createView(),
  189.             'messages' => $messages,
  190.             'current_menu' => 'message',
  191.             'haveOffice' => $haveOffice
  192.         ]);
  193.     }
  195.     /**
  196.      * @Route("/json/message/new", name="have_message_new_json", options = { "expose" = true })
  197.      * vérifie s'il existe des messages non lus afin d'afficher une notification
  198.      */
  199.     public function ajaxHaveNewMessage(?UserInterface $user, MessagePatientRepository $messagePatientRepository, EntityManagerInterface $entityManager)
  200.     {
  202.         if (!$user) {
  203.             return new JsonResponse(0);
  204.         }
  206.         if ($user->getIsProfessional()) {//si l'utilisateur est un professionnel
  208.             $idUser = $user->getId();
  209.             $notifications = $entityManager->getRepository('App\Entity\Notification')->findBy(['user' => $idUser, 'isViewed' => '0'], ['createdAt' => 'DESC'], 1);
  211.             if (empty($notifications)) {
  212.                 return new JsonResponse(0);
  213.             } else {
  214.                 return new JsonResponse(1);
  215.             }
  217. //            $officeMessagesNotViewInCache = $cache->getItem('number_messages.from.patient');
  218. //            //si le nombre de message est en cache
  219. //            if($officeMessagesNotViewInCache->isHit()){
  220. //                if(count($officeMessagesNotViewInCache->get()) > 0){
  221. //                    return new JsonResponse(1);
  222. //                }
  223. //                return new JsonResponse(0);
  224. //            }
  225. //
  226. //            $office = $user->getOffice();
  227. //            $users = $office->getUsers();
  228. //            $arrayPatient = [];
  229. //            foreach ($users as $user){
  230. //                if(!$user->getIsProfessional()){
  231. //                    $arrayPatient[] = $user->getPatient()->getId();//récupère les patients du cabinet
  232. //                }
  233. //            }
  234. //            $officeMessagesNotView = $messagePatientRepository->getMessageNotViewForPatients($arrayPatient);
  235. //            $officeMessagesNotViewInCache = $cache->getItem('number_messages.from.patient'); //création du cache
  236. //            $officeMessagesNotViewInCache->set($officeMessagesNotView); //mise en cache du nombre de message
  237. //            $officeMessagesNotViewInCache->expiresAfter(7200); //durée du cache
  238. //            $cache->save($officeMessagesNotViewInCache); //sauvegarde du cache
  239. //
  240. //            if(count($officeMessagesNotView) > 0){
  241. //                return new JsonResponse(1);
  242. //            }
  243.         } else {
  245. //            $cache = new FilesystemAdapter();
  246. //            $officeMessagesNotViewInCache = $cache->getItem('number_messages.from.professional');
  247. //
  248. //            //si le nombre de message est en cache
  249. //            if ($officeMessagesNotViewInCache->isHit()) {
  250. //                if (count($officeMessagesNotViewInCache->get()) > 0) {
  251. //                    return new JsonResponse(1);
  252. //                }
  253. //                return new JsonResponse(0);
  254. //            }
  256.             $idPatient = $user->getPatient()->getId();
  257.             $officeMessagesNotView = $messagePatientRepository->findBy(['view' => 0, 'type' => 1, 'affectedPatient' => $idPatient]);
  258. //            $officeMessagesNotViewInCache = $cache->getItem('number_messages.from.professional'); //création du cache
  259. //            $officeMessagesNotViewInCache->set($officeMessagesNotView); //mise en cache du nombre de message
  260. //            $officeMessagesNotViewInCache->expiresAfter(7200); //durée du cache
  261. //            $cache->save($officeMessagesNotViewInCache); //sauvegarde du cache
  263.             if (count($officeMessagesNotView) > 0) {
  264.                 return new JsonResponse(1);
  265.             }
  266.         }
  267.         return new JsonResponse(0);
  268.     }
  270. }