src/Controller/COMUNICACIONES/Announcement.php line 100

Open in your IDE?
  1. <?php
  3. namespace App\Controller\COMUNICACIONES;
  5. use App\Controller\_USER\Nuser;
  6. use App\Controller\RequestTransform;
  7. use App\Entity\Msg;
  8. use App\Entity\MsgEntry;
  9. use App\Entity\Usuario;
  10. use App\Repository\BaseRepository;
  11. use App\Repository\Sql\CursosRepository;
  12. use App\Repository\Sql\MsgRepository;
  13. use App\Repository\Sql\TemaRepository;
  14. use App\Services\Files\FileUploader;
  15. use App\Services\MsgService\MsgService;
  16. use App\Services\Password\EncoderService;
  17. use App\Services\SqlService\SqlService;
  18. use App\Services\TemaService\TemaService;
  19. use App\Services\UserService\UserService;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\Mailer\MailerInterface;
  25. use Symfony\Component\Routing\Annotation\Route;
  26. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  27. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  28. use Symfony\Component\Serializer\Serializer;
  30. class Announcement extends AbstractController
  31. {
  32.     private $cursosRepository;
  33.     private $temaService;
  34.     private $msgRepository;
  35.     private $temaRepository;
  36.     private $encoderService;
  37.     private $em;
  38.     private $nuser;
  39.     private $msgService;
  40.     private $sqlService;
  41.     private $userService;
  42.     private $mailer;
  44.     public function __construct(
  45.         EntityManagerInterface $em,
  46.         EncoderService $encoderService,
  47.         CursosRepository $cursosRepository,
  48.         MsgRepository $msgRepository,
  49.         TemaRepository $temaRepository,
  50.         Nuser $nuser,
  51.         TemaService $temaService,
  52.         MsgService $msgService,
  53.         SqlService $sqlService,
  54.         UserService $userService,
  55.         MailerInterface $mailer
  56.     ) {
  57.         $this->nuser = $nuser;
  58.         $this->em = $em;
  59.         $this->encoderService = $encoderService;
  60.         $this->msgRepository = $msgRepository;
  61.         $this->temaService = $temaService;
  62.         $this->msgService = $msgService;
  63.         $this->cursosRepository = $cursosRepository;
  64.         $this->temaRepository = $temaRepository;
  65.         $this->sqlService = $sqlService;
  66.         $this->userService = $userService;
  67.         $this->mailer = $mailer;
  69.         $encoders = [new JsonEncoder()];
  70.         $normalizers = [new ObjectNormalizer()];
  71.         $this->serializer = new Serializer($normalizers, $encoders);
  72.     }
  74.     /**
  75.      * Show a particular user announcements with no update.
  76.      *
  77.      * @Route("/api/msg/user/announcement/list", name="get_msg_user_announcement_list", methods={"POST"})
  78.      */
  79.     public function getUserAnnouncementList(Request $request): JsonResponse
  80.     {
  81.         $userInformation = $this->userService->decodeToken($request);
  82.         $pageNumber = RequestTransform::getRequiredField($request, 'page');
  83.         $category = RequestTransform::getRequiredField($request, 'category', false, true) ?: null;
  84.         $course = RequestTransform::getRequiredField($request, 'course', false, true) ?: null;
  86.         $msgs = $this->msgService->getUserAnnouncementList($userInformation['uuid'], $course, $category, $pageNumber);
  88.         return new JsonResponse([
  89.             'code' => $msgs['code'],
  90.             'message' => 'get_msg_user_announcement_list',
  91.             'id' => 200 == $msgs['code'] ? $this->serializer->serialize($msgs['id'], 'json') : $msgs['id'],
  92.         ]);
  93.     }
  95.     /**
  96.      * Get the number of new announcements for a specific user with no update to read.
  97.      *
  98.      * @Route("/api/anuncio/new", name="anuncio_new_announcement", methods={"POST"})
  99.      */
  100.     public function userAnnouncementsList(Request $request): JsonResponse
  101.     {
  102.         $userInformation = $this->userService->decodeToken($request);
  103.         $course = RequestTransform::getRequiredField($request, 'course', false, true) ?: null;
  105.         $announcementsAndNews = $this->msgService->getAnnouncementsWithNews($userInformation['uuid'], $course, null, true);
  107.         if (!is_null($announcementsAndNews)) {
  108.             return new JsonResponse([
  109.                 'code' => 200,
  110.                 'message' => 'anuncio_new_announcement',
  111.                 'result' => $announcementsAndNews,
  112.             ]);
  113.         }
  115.         return new JsonResponse([
  116.             'code' => 400,
  117.             'message' => 'anuncio_new_announcement',
  118.             'result' => [],
  119.         ]);
  120.     }
  122.     /**
  123.      * Show a list of announcements.
  124.      *
  125.      * @Route("/api/msg/admin/announcement/list", name="get_msg_admin_announcement_list", methods={"POST"})
  126.      */
  127.     public function getAdminAnnouncementList(Request $request): JsonResponse
  128.     {
  129.         $userInformation = $this->userService->decodeToken($request);
  130.         $pageNumber = RequestTransform::getRequiredField($request, 'page');
  131.         $category = RequestTransform::getRequiredField($request, 'category', false, true) ?: null;
  132.         $search = RequestTransform::getRequiredField($request, 'search', false, true) ?: null;
  134.         $msgs = $this->msgService->getAdminAnnouncementList($userInformation['uuid'], $category, $pageNumber, $search);
  136.         return new JsonResponse([
  137.             'code' => $msgs['code'],
  138.             'message' => 'get_msg_user_announcement_list',
  139.             'id' => 200 == $msgs['code'] ? $this->serializer->serialize($msgs['id'], 'json') : $msgs['id'],
  140.         ]);
  141.     }
  143.     /**
  144.      * Show communications with teachers, secretaries and admins.
  145.      *
  146.      * @param Request $request when consulting a message
  147.      *
  148.      * @Route("/api/msg/admin/doubt/list", name="get_msg_admin_doubt_list", methods={"POST"})
  149.      */
  150.     public function getMsgAdminDoubtList(Request $request): JsonResponse
  151.     {
  152.         $userInformation = $this->userService->decodeToken($request);
  153.         $pageNumber = RequestTransform::getRequiredField($request, 'page');
  154.         $msgType = RequestTransform::getRequiredField($request, 'type');
  155.         $msgStatus = RequestTransform::getRequiredField($request, 'status');
  156.         $area = RequestTransform::getRequiredField($request, 'area', false, true) ?: null;
  157.         $sede = RequestTransform::getRequiredField($request, 'sede', false, true) ?: null;
  158.         $seeAsTutor = RequestTransform::getRequiredField($request, 'seeAsTutor', false, true) ?: null;
  160.         $msgs = $this->msgService->getAdminDoubtsList($userInformation['uuid'], $pageNumber, $msgType, $msgStatus, $area, $sede, $seeAsTutor);
  162.         return new JsonResponse([
  163.             'code' => $msgs['code'],
  164.             'message' => 'get_msg_admin_doubt_list',
  165.             'id' => 200 == $msgs['code'] ? $this->serializer->serialize($msgs['id'], 'json') : $msgs['id'],
  166.         ]);
  167.     }
  169.     /**
  170.      * Show communications created.
  171.      *
  172.      * @Route("/api/msg/user/doubt/list", name="get_msg_user_doubt_list", methods={"POST"})
  173.      */
  174.     public function getMsgUserDoubtList(Request $request): JsonResponse
  175.     {
  176.         $userInformation = $this->userService->decodeToken($request);
  177.         $pageNumber = RequestTransform::getRequiredField($request, 'page');
  178.         $msgStatus = RequestTransform::getRequiredField($request, 'status');
  180.         $msgs = $this->msgService->getUserDoubtsList($userInformation['uuid'], $pageNumber, $msgStatus);
  182.         return new JsonResponse([
  183.             'code' => $msgs['code'],
  184.             'message' => 'get_msg_user_doubt_list',
  185.             'id' => 200 == $msgs['code'] ? $this->serializer->serialize($msgs['id'], 'json') : $msgs['id'],
  186.         ]);
  187.     }
  189.     /**
  190.      * Details about an announcement.
  191.      *
  192.      * @param string $msg_id ID of the message
  193.      *
  194.      * @Route("/api/details/announcement/{msg_id}", name="announcement_get_details", methods={"GET"})
  195.      */
  196.     public function showDetailsAnnouncement(string $msg_id): JsonResponse
  197.     {
  198.         $announcement = $this->msgService->getAnnouncementDetails($msg_id);
  200.         if ($announcement) {
  201.             return new JsonResponse([
  202.                 'code' => 200,
  203.                 'message' => 'announcement_get_details',
  204.                 'result' => $announcement,
  205.             ]);
  206.         }
  208.         return new JsonResponse([
  209.             'code' => 404,
  210.             'message' => 'announcement_get_details',
  211.             'result' => $announcement,
  212.         ]);
  213.     }
  215.     /**
  216.      * Details about an announcement.
  217.      *
  218.      * @param string $msg_id ID of the message
  219.      *
  220.      * @Route("/api/msg/user/comunication/{course_id}", name="comunication_get_access", methods={"GET"})
  221.      */
  222.     public function hasCourseAccessComunication(string $course_id): JsonResponse
  223.     {
  224.         $courses = explode(',', $course_id);
  225.         $access = $this->msgService->hasCourseAccessComunication($courses);
  227.         if ($access) {
  228.             return new JsonResponse([
  229.                 'code' => 200,
  230.                 'message' => 'comunication_get_access',
  231.                 'result' => $access,
  232.             ]);
  233.         }
  235.         return new JsonResponse([
  236.             'code' => 404,
  237.             'message' => 'comunication_get_access',
  238.             'result' => $access,
  239.         ]);
  240.     }
  242.     /**
  243.      * Details about an announcement.
  244.      *
  245.      * @param string $msg_id ID of the message
  246.      *
  247.      * @Route("/api/msg/user/all/comunication", name="comunication_get_user_access", methods={"GET"})
  248.      */
  249.     public function getUserAccessComunication(Request $request): JsonResponse
  250.     {
  251.         $userInformation = $this->userService->decodeToken($request);
  252.         $access = $this->msgService->getUserCoursesAccess($userInformation['uuid']);
  254.         if ($access) {
  255.             return new JsonResponse([
  256.                 'code' => 200,
  257.                 'message' => 'comunication_get_user_access',
  258.                 'result' => $access,
  259.             ]);
  260.         }
  262.         return new JsonResponse([
  263.             'code' => 404,
  264.             'message' => 'comunication_get_user_access',
  265.             'result' => $access,
  266.         ]);
  267.     }
  269.     /**
  270.      * Details about a conversation (doubt).
  271.      *
  272.      * @param string  $msgId   ID of the message
  273.      * @param Request $request when consulting a message
  274.      *
  275.      * @Route("/api/msg/doubt/details/{msgId}", name="get_msg_doubt_details", methods={"GET"})
  276.      */
  277.     public function getMsgDoubtDetails(string $msgId, Request $request): JsonResponse
  278.     {
  279.         $userInformation = $this->userService->decodeToken($request);
  281.         $msgs = $this->msgService->getDoubtDetails($msgId, $userInformation['uuid']);
  283.         return new JsonResponse([
  284.             'code' => $msgs['code'],
  285.             'message' => 'get_msg_doubt_details',
  286.             'result' => $msgs['result'],
  287.         ]);
  288.     }
  290.     /**
  291.      * Auxiliary functions for creating messages.
  292.      *
  293.      * @param $msg Msg msg object to creat or edit
  294.      * @param $sentBy Usuario user that created the message
  295.      * @param $type String type of message: announcement, doubt or feedback
  296.      * @param $title String title of the message
  297.      * @param $message String content of the message
  298.      * @param $keyValueArray array for msg KV
  299.      * @param $request Request when a new announcement is submitted
  300.      * @param $repository BaseRepository to make SQL calls using ORM
  301.      * @param $sqlService SqlService to make SQL calls
  302.      *
  303.      * @return array
  304.      */
  305.     private function createNewMessage(Msg $msg, Usuario $sentBy, string $type, string $title, string $message, array $keyValueArray, Request $request, BaseRepository $repository, SqlService $sqlService)
  306.     {
  307.         $exception = [];
  309.         $today = new \DateTime();
  310.         $createdBy = null == $msg->getCreatedBy() ? $sentBy : $msg->getCreatedBy();
  311.         $createdAt = null == $msg->getCreatedAt() ? $today : $msg->getCreatedAt();
  313.         // Message information
  314.         $msg->setCreatedBy($createdBy);
  315.         $msg->setCreatedAt($createdAt);
  316.         $msg->setModifiedAt($today);
  317.         $msg->setTitle($title);
  318.         $msg->setType($type);
  319.         $exception_msg = $repository->add($msg);
  321.         if (200 == $exception_msg['code']) {
  322.             // Message Entry information
  323.             $msgEntry = $repository->isId($request, MsgEntry::class);
  324.             $msgEntry->setIdMsg($msg);
  325.             $msgEntry->setCreatedBy($createdBy);
  326.             $msgEntry->setModifiedBy($sentBy);
  327.             $msgEntry->setCreatedAt($createdAt);
  328.             $msgEntry->setModifiedAt($today);
  329.             $msgEntry->setText($message);
  330.             $exception_msgEntry = $repository->add($msgEntry);
  332.             if (200 == $exception_msgEntry['code']) {
  333.                 // Para cada clave valor crear un insert en Msg_Entry (con su clave, valor).
  334.                 $exception_msgKv = $sqlService->generateMsgKvSql($msg, $keyValueArray);
  336.                 if (200 == $exception_msgKv[0]['code']) {
  337.                     // Exception message if exit
  338.                     $exception = [
  339.                         'code' => 200,
  340.                         'message' => 'success',
  341.                         'id' => [
  342.                             'msg' => $exception_msg['id'],
  343.                             'msgEntry' => $exception_msgEntry['id'],
  344.                         ],
  345.                     ];
  346.                     $msgKv_ids = [];
  347.                     foreach ($exception_msgKv as $insert) {
  348.                         if (200 != $insert['code']) {
  349.                             return new JsonResponse([
  350.                                 'code' => $insert['code'],
  351.                                 'message' => $insert['message'],
  352.                                 'id' => $insert['id'],
  353.                             ]);
  354.                         } else {
  355.                             array_push($msgKv_ids, $insert['id']);
  356.                         }
  357.                     }
  358.                     $exception['id']['msgKv'] = $msgKv_ids;
  359.                 }
  360.             }
  361.         }
  363.         return $exception;
  364.     }
  366.     /**
  367.      * Create a new Announcement.
  368.      *
  369.      * @param $request Request when a new announcement is submitted
  370.      *
  371.      * @Route("/api/anuncio/add", name="anuncio_add", methods={"POST"})
  372.      * @Route("/api/anuncio/edit/{id}", name="anuncio_edit", methods={"POST"})
  373.      */
  374.     public function newAnnouncement(Request $request): JsonResponse
  375.     {
  376.         $title = RequestTransform::getRequiredField($request, 'title');
  377.         $message = RequestTransform::getRequiredField($request, 'message');
  378.         $category = RequestTransform::getRequiredField($request, 'category');
  379.         $dateStart = RequestTransform::getRequiredField($request, 'dateStart');
  380.         $dateEnd = RequestTransform::getRequiredField($request, 'dateEnd', false, true) ?: null;
  381.         $showOnPanel = RequestTransform::getRequiredField($request, 'showOnPanel');
  382.         $sendEmail = RequestTransform::getRequiredField($request, 'sendEmail');
  383.         $isEnabled = RequestTransform::getRequiredField($request, 'isEnabled');
  384.         $sedes = RequestTransform::getRequiredField($request, 'sedes', true, true) ?: null;
  385.         $areas = RequestTransform::getRequiredField($request, 'areas', true, true) ?: null;
  386.         $currentCursos = RequestTransform::getRequiredField($request, 'currentCursos', true, true);
  387.         $previousCursos = RequestTransform::getRequiredField($request, 'previousCursos', true, true);
  388.         $nextCursos = RequestTransform::getRequiredField($request, 'nextCursos', true, true);
  389.         $superPromotions = RequestTransform::getRequiredField($request, 'superPromotions', true, true);
  390.         $users = RequestTransform::getRequiredField($request, 'users') ?: null;
  391.         $msgId = RequestTransform::getRequiredField($request, 'id', false, true) ?: null;
  392.         $filesToServer = RequestTransform::getRequiredField($request, 'fichero', false, true);
  393.         $filesFromServer = RequestTransform::getRequiredField($request, 'filesFromServer', true, true);
  395.         $userInformation = $this->userService->decodeToken($request);
  397.         $cursos = array_merge($currentCursos, $previousCursos, $nextCursos) ?: null;
  399.         $keyValueArray = [
  400.             'inicio' => date('d-m-Y', strtotime($dateStart)),
  401.             'fin' => $dateEnd ? date('d-m-Y', strtotime($dateEnd)) : null,
  402.             'habilitado' => $isEnabled ? 1 : 0,
  403.             'visualizar' => $showOnPanel ? 1 : 0,
  404.             'email' => $sendEmail ? 1 : 0,
  405.             'user' => $users,
  406.             'category' => $category,
  407.             'curso' => $cursos,
  408.             'area' => $areas,
  409.             'sede' => $sedes,
  410.             'super_promocion' => $superPromotions,
  411.             'filesToServer' => $filesToServer ?: null,
  412.             'fichero' => $filesFromServer,
  413.         ];
  415.         $announcement = $this->msgService->addNewAnnouncement($userInformation['uuid'], 0, $title, $message, $keyValueArray, $msgId, $filesToServer);
  417.         if ($announcement) {
  418.             return new JsonResponse([
  419.                 'code' => 200,
  420.                 'message' => 'anuncio_add',
  421.                 'id' => $announcement,
  422.             ]);
  423.         }
  425.         return new JsonResponse([
  426.             'code' => 400,
  427.             'message' => 'anuncio_add',
  428.             'id' => $announcement,
  429.         ]);
  430.     }
  432.     /**
  433.      * Upload a file to a announcement.
  434.      *
  435.      * @param Request $request from the multi-file-upload.server
  436.      *
  437.      * @Route("/api/anuncio/add/image", name="fichero_anuncio", methods={"POST"})
  438.      */
  439.     public function announcementFiles(Request $request): JsonResponse
  440.     {
  441.         $title = $request->request->get('title');
  442.         $message = $request->request->get('message');
  443.         $array_key_values = $request->request->get('key_value_array');
  445.         $uploadedFile = $request->files->get('picture');
  446.         $me_id = $request->request->get('id');
  448.         if ($uploadedFile) {
  449.             foreach ($uploadedFile as $key => $value) {
  450.                 $e[] = $this->msgService->uploadFileToAnnouncement($value, $me_id);
  451.             }
  453.             $array = (array) json_decode($array_key_values);
  455.             if ($title && $message && $array && $e) {
  456.                 $this->msgService->sendEmail($title, $message, $array, $e);
  457.             }
  459.             if ($e) {
  460.                 return new JsonResponse([
  461.                     'code' => 200,
  462.                     'message' => 'fichero_anuncio',
  463.                     'id' => $me_id,
  464.                 ]);
  465.             }
  467.             return new JsonResponse([
  468.                 'code' => 500,
  469.                 'message' => $e->getMessage(),
  470.                 'id' => $me_id,
  471.             ]);
  472.         }
  474.         return new JsonResponse([
  475.             'code' => 404,
  476.             'message' => 'File not found',
  477.             'id' => $me_id,
  478.         ]);
  479.     }
  481.     /**
  482.      * Create a new Message.
  483.      *
  484.      * @param Request        $request    when a new doubt is submitted
  485.      * @param BaseRepository $repository to make SQL calls using ORM
  486.      * @param SqlService     $sqlService to make SQL calls
  487.      *
  488.      * @Route("/api/duda/add", name="duda_add", methods={"POST"})
  489.      */
  490.     public function newDoubt(Request $request, BaseRepository $repository, SqlService $sqlService): JsonResponse
  491.     {
  492.         // Request
  493.         $user_information = $this->userService->decodeToken($request);
  494.         $title = RequestTransform::getRequiredField($request, 'title');
  495.         $message = RequestTransform::getRequiredField($request, 'message');
  496.         $addressee = RequestTransform::getRequiredField($request, 'destino');
  497.         $campus = RequestTransform::getRequiredField($request, 'sede');
  498.         $grade = RequestTransform::getRequiredField($request, 'curso');
  499.         $unit = RequestTransform::getRequiredField($request, 'tema');
  501.         $msg = $repository->isId($request, Msg::class);
  502.         $sentBy = $this->em->getRepository(Usuario::class)->find($user_information['uuid']);
  504.         $keyValueArray = [
  505.             'estado' => 0,
  506.         ];
  508.         switch ($addressee) {
  509.             case 1: // Unit doubts
  510.                 $keyValueArray['tema'] = $unit;
  511.                 $keyValueArray['curso'] = $grade;
  512.                 break;
  513.             case 2: // Secretary
  514.                 $keyValueArray['sede'] = $campus;
  515.                 break;
  516.         }
  517.         $exception = $this->createNewMessage($msg, $sentBy, $addressee, $title, $message, $keyValueArray, $request, $repository, $sqlService);
  519.         return new JsonResponse($exception);
  520.     }
  522.     /**
  523.      * Create a new feedback message from test.
  524.      *
  525.      * @param Request $request when a new doubt is submitted
  526.      *
  527.      * @Route("/api/retroalimentacion/add", name="feedback_add", methods={"POST"})
  528.      */
  529.     public function newFeedback(Request $request): JsonResponse
  530.     {
  531.         $userInformation = $this->userService->decodeToken($request);
  532.         $course = RequestTransform::getRequiredField($request, 'course');
  533.         $questionId = RequestTransform::getRequiredField($request, 'question');
  534.         $testId = RequestTransform::getRequiredField($request, 'test');
  535.         $message = RequestTransform::getRequiredField($request, 'message');
  537.         $feedback_id = $this->msgService->addNewFeedback($userInformation['uuid'], $course, $questionId, $testId, $message);
  539.         return new JsonResponse([
  540.             'code' => 200,
  541.             'message' => 'feedback_add',
  542.             'result' => $feedback_id,
  543.         ]);
  544.     }
  546.     /**
  547.      * Upload a file to a msg.
  548.      *
  549.      * @param Request      $request      from the multi-file-upload.server
  550.      * @param FileUploader $fileUploader to upload the image to the server
  551.      *
  552.      * @Route("/api/details/msg/add/image", name="image_msg", methods={"POST"})
  553.      */
  554.     public function msgFiles(Request $request, FileUploader $fileUploader): JsonResponse
  555.     {
  556.         $uploadedFile = $request->files->get('picture');
  557.         $me_id = $request->request->get('id');
  559.         if ($uploadedFile) {
  560.             try {
  561.                 $urlFileName = $fileUploader->upload($uploadedFile, '/msg');
  563.                 $me = $this->em->getRepository(MsgEntry::class)->find($me_id);
  564.                 $msg_id = $me->getIdMsg()->getId();
  566.                 $exception = $this->sqlService->genericInsert('msg_kv', [
  567.                     'id_msg_id' => $msg_id,
  568.                     'field' => 'fichero',
  569.                     'value' => $urlFileName,
  570.                 ]);
  572.                 return new JsonResponse([
  573.                     'code' => 200,
  574.                     'message' => $exception,
  575.                 ]);
  576.             } catch (\Exception $e) {
  577.                 return new JsonResponse(['code' => 500, 'message' => $e->getMessage()]);
  578.             }
  579.         }
  581.         return new JsonResponse(['code' => 404, 'message' => 'File not found']);
  582.     }
  584.     /**
  585.      * Answer a conversation.
  586.      *
  587.      * @param $request Request when a new reply is submitted
  588.      *
  589.      * @Route("/api/details/msg/add", name="msg_answer", methods={"POST"})
  590.      */
  591.     public function newAnswer(Request $request): JsonResponse
  592.     {
  593.         $user_information = $this->userService->decodeToken($request);
  594.         $msg = RequestTransform::getRequiredField($request, 'msg');
  595.         $message = RequestTransform::getRequiredField($request, 'message');
  597.         $msg_entry_id = $this->msgService->addMsgEntry($user_information['uuid'], $message, $msg);
  599.         return new JsonResponse([
  600.             'code' => 200,
  601.             'message' => 'msg_answer',
  602.             'result' => $msg_entry_id,
  603.         ]);
  604.     }
  606.     /**
  607.      * Answer a conversation and change status to published.
  608.      *
  609.      * @param $request Request when a new reply is submitted
  610.      *
  611.      * @Route("/api/details/msg/add/publish", name="msg_answer_and_publish", methods={"POST"})
  612.      */
  613.     public function addAnswerAndPublish(Request $request): JsonResponse
  614.     {
  615.         $user_information = $this->userService->decodeToken($request);
  616.         $msg = RequestTransform::getRequiredField($request, 'msg');
  617.         $message = RequestTransform::getRequiredField($request, 'message');
  619.         $msg_entry_id = $this->msgService->addMsgEntry($user_information['uuid'], $message, $msg);
  620.         $msg_id = $msg['id'];
  621.         $this->msgService->switchMsgPublishStatus($msg_id, 1);
  623.         return new JsonResponse([
  624.             'code' => 200,
  625.             'message' => 'msg_answer_and_publish',
  626.             'result' => $msg_entry_id,
  627.         ]);
  628.     }
  630.     /**
  631.      * Modify an existing message.
  632.      *
  633.      * @Route("/api/details/msg/edit", name="msg_answer_edit", methods={"PUT"})
  634.      */
  635.     public function editAnswer(Request $request): JsonResponse
  636.     {
  637.         $user_information = $this->userService->decodeToken($request);
  638.         $msg_entry_id = RequestTransform::getRequiredField($request, 'id');
  639.         $text = RequestTransform::getRequiredField($request, 'message');
  641.         $updated = $this->msgService->editMsgEntry($user_information['uuid'], $text, $msg_entry_id);
  643.         if ($updated) {
  644.             return new JsonResponse([
  645.                 'code' => 200,
  646.                 'message' => 'msg_answer_edit',
  647.                 'result' => $msg_entry_id,
  648.             ]);
  649.         }
  651.         return new JsonResponse([
  652.             'code' => 400,
  653.             'message' => 'msg_answer_edit',
  654.             'result' => $msg_entry_id,
  655.         ]);
  656.     }
  658.     /**
  659.      * Publish existing messages.
  660.      *
  661.      * @Route("/api/details/msg/switchPublish", name="msg_switch_publish", methods={"PUT"})
  662.      */
  663.     public function switchPublishAnswers(Request $request): JsonResponse
  664.     {
  665.         $msg_id = RequestTransform::getRequiredField($request, 'msgId');
  666.         $published = RequestTransform::getRequiredField($request, 'estadoPublicacion');
  668.         $updated = $this->msgService->switchMsgPublishStatus($msg_id, $published);
  670.         if ($updated) {
  671.             return new JsonResponse([
  672.                 'code' => 200,
  673.                 'message' => 'msg_switch_publish',
  674.                 'result' => $msg_id,
  675.             ]);
  676.         }
  678.         return new JsonResponse([
  679.             'code' => 400,
  680.             'message' => 'msg_switch_publish',
  681.             'result' => [],
  682.         ]);
  683.     }
  685.     /**
  686.      * Change message type.
  687.      *
  688.      * @Route("/api/details/msg/changeType", name="msg_change_type", methods={"PUT"})
  689.      */
  690.     public function changeMsgType(Request $request): JsonResponse
  691.     {
  692.         $msg_id = RequestTransform::getRequiredField($request, 'msgId');
  693.         $msg_type = RequestTransform::getRequiredField($request, 'msgType');
  694.         $curso = RequestTransform::getRequiredField($request, 'curso', true, true);
  695.         $tema = RequestTransform::getRequiredField($request, 'tema', true, true);
  696.         $sede = RequestTransform::getRequiredField($request, 'sede', true, true);
  698.         $values = [
  699.             'curso' => $curso,
  700.             'tema' => $tema,
  701.             'sede' => $sede,
  702.         ];
  704.         $type_changed = $this->msgService->changeMsgType($msg_id, $msg_type, $values);
  706.         if ($type_changed) {
  707.             return new JsonResponse([
  708.                 'code' => 200,
  709.                 'message' => 'msg_change_type',
  710.                 'result' => $type_changed,
  711.             ]);
  712.         }
  714.         return new JsonResponse([
  715.             'code' => 400,
  716.             'message' => 'msg_change_type',
  717.             'result' => $type_changed,
  718.         ]);
  719.     }
  721.     /**
  722.      * Change message status.
  723.      *
  724.      * @Route("/api/details/msg/changeStatus", name="msg_change_status", methods={"PUT"})
  725.      */
  726.     public function changeMsgStatus(Request $request): JsonResponse
  727.     {
  728.         $msg_id = RequestTransform::getRequiredField($request, 'msgId');
  729.         $msg_status = RequestTransform::getRequiredField($request, 'msgStatus');
  731.         $status_changed = $this->msgService->changeMsgStatus($msg_id, $msg_status);
  733.         if ($status_changed) {
  734.             return new JsonResponse([
  735.                 'code' => 200,
  736.                 'message' => 'msg_change_status',
  737.                 'result' => $status_changed,
  738.             ]);
  739.         }
  741.         return new JsonResponse([
  742.             'code' => 400,
  743.             'message' => 'msg_change_status',
  744.             'result' => $status_changed,
  745.         ]);
  746.     }
  748.     /**
  749.      * Switches a Msg (announcement) to be enabled or disabled.
  750.      *
  751.      * @Route("/api/msg/announcement/enable", name="msg_announcement_enable", methods={"PUT"})
  752.      */
  753.     public function switchEnableMsg(Request $request): JsonResponse
  754.     {
  755.         $userInformation = $this->userService->decodeToken($request);
  756.         $msgId = RequestTransform::getRequiredField($request, 'msgId');
  758.         $isMsgEnabled = $this->msgService->switchMsgEnableStatus($msgId, $userInformation['uuid']);
  760.         if (is_null($isMsgEnabled)) {
  761.             return new JsonResponse([
  762.                 'code' => 403,
  763.                 'message' => 'msg_announcement_enable',
  764.                 'result' => [],
  765.             ]);
  766.         }
  768.         return new JsonResponse([
  769.             'code' => 200,
  770.             'message' => 'msg_announcement_enable',
  771.             'result' => $msgId,
  772.         ]);
  773.     }
  775.     /**
  776.      * Deletes a messages with all its entries, reads and kvs.
  777.      *
  778.      * @param string $msg_id Message id
  779.      *
  780.      * @Route("/api/msg/{msg_id}", name="msg_delete" , methods={"DELETE"})
  781.      */
  782.     public function deleteMsg(string $msg_id): JsonResponse
  783.     {
  784.         if ($msg_id) {
  785.             $em = $this->getDoctrine()->getManager();
  786.             $msg = $em->getRepository(Msg::class)->find($msg_id);
  787.             if ($msg) {
  788.                 $em->remove($msg);
  789.                 $em->flush();
  790.                 $exception = [
  791.                     'code' => 200,
  792.                     'message' => 'success',
  793.                     'id' => $msg_id,
  794.                 ];
  795.             } else {
  796.                 $exception = [
  797.                     'code' => 404,
  798.                     'message' => 'Not found',
  799.                     'id' => $msg_id,
  800.                 ];
  801.             }
  803.             return new JsonResponse($exception);
  804.         }
  805.         return new JsonResponse([
  806.             'code' => 200,
  807.             'message' => 'msg_announcement_enable',
  808.             'result' => 'error',
  809.         ]);
  811.     }
  813.     /**
  814.      * Deletes a Msg.
  815.      *
  816.      * @Route("/api/details/msg/delete", name="msg_delete_bd", methods={"PUT"})
  817.      */
  818.     public function deleteMsgBd(Request $request): JsonResponse
  819.     {
  820.         $userInformation = $this->userService->decodeToken($request);
  821.         $msgId = RequestTransform::getRequiredField($request, 'msgId');
  823.         $isMsgEnabled = $this->msgService->deleteMsg($msgId, $userInformation['uuid']);
  825.         if (is_null($isMsgEnabled)) {
  826.             return new JsonResponse([
  827.                 'code' => 403,
  828.                 'message' => 'msg_announcement_enable',
  829.                 'result' => [],
  830.             ]);
  831.         }
  833.         return new JsonResponse([
  834.             'code' => 200,
  835.             'message' => 'msg_announcement_enable',
  836.             'result' => $msgId,
  837.         ]);
  838.     }
  840.     /**
  841.      * Show feedback list.
  842.      *
  843.      * @Route("/api/msg/feedback/list", name="get_msg_feedback_list", methods={"POST"})
  844.      */
  845.     public function getFeedbackList(Request $request): JsonResponse
  846.     {
  847.         $userInformation = $this->userService->decodeToken($request);
  848.         $pageNumber = RequestTransform::getRequiredField($request, 'page');
  849.         $msgStatus = RequestTransform::getRequiredField($request, 'status');
  850.         $area = RequestTransform::getRequiredField($request, 'area', false, true) ?: null;
  851.         $sede = RequestTransform::getRequiredField($request, 'sede', false, true) ?: null;
  852.         $seeAsTutor = RequestTransform::getRequiredField($request, 'seeAsTutor', false, true) ?: null;
  854.         $msgs = $this->msgService->getFeedbackList($userInformation['uuid'], $pageNumber, $msgStatus, $area, $sede, $seeAsTutor);
  856.         return new JsonResponse([
  857.             'code' => $msgs['code'],
  858.             'message' => 'get_msg_feedback_list',
  859.             'id' => 200 == $msgs['code'] ? $this->serializer->serialize($msgs['id'], 'json') : $msgs['id'],
  860.         ]);
  861.     }
  863.     /**
  864.      * Details about a conversation (feedback).
  865.      *
  866.      * @param string  $msgId   ID of the message
  867.      * @param Request $request when consulting a message
  868.      *
  869.      * @Route("/api/msg/feedback/details/{msgId}", name="get_msg_feedback_details", methods={"GET"})
  870.      */
  871.     public function getFeedbackDetails(string $msgId, Request $request): JsonResponse
  872.     {
  873.         $userInformation = $this->userService->decodeToken($request);
  875.         $msgs = $this->msgService->getFeedbackDetails($msgId, $userInformation['uuid']);
  877.         return new JsonResponse([
  878.             'code' => $msgs['code'],
  879.             'message' => 'get_msg_feedback_details',
  880.             'result' => $msgs['result'],
  881.         ]);
  882.     }
  883. }