src/Controller/Api/AbsenceController.php line 43

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api;
  5. use App\Entity\Absence;
  6. use App\Entity\Notifications;
  7. use App\Entity\StudentYear;
  8. use App\Repository\AbsenceRepository;
  9. use App\Repository\NotificationsRepository;
  10. use App\Repository\SchoolYearRepository;
  11. use App\Repository\StudentRepository;
  12. use App\Repository\StudentYearRepository;
  13. use App\Repository\UserRepository;
  14. use App\Repository\UserYearRepository;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use JMS\Serializer\SerializationContext;
  17. use JMS\Serializer\SerializerInterface;
  18. use Knp\Component\Pager\PaginatorInterface;
  19. use OpenApi\Annotations as OA;
  20. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use Symfony\Component\Routing\Annotation\Route;
  25. use Twig\Environment;
  26. use Symfony\Component\Mercure\HubInterface;
  27. use Symfony\Component\Mercure\Update;
  28. use App\Repository\SubjectRepository;
  29. use App\Repository\ExamsRepository;
  30. use App\Service\PushNotificationService;
  31. use App\Entity\UserNotifications;
  32. use App\Repository\TheClassRepository;
  34. class AbsenceController extends AbstractController
  35. {
  38.      /**
  39.      * Absence parents index
  40.      * @OA\Tag(name="Absence")
  41.      */
  42.     #[Route("/api/parent/students/absences/",name: 'api_parent_absence_student_list', methods: ['GET'])]
  43.     public function parentsGetAbsenceIndex(
  44.         SchoolYearRepository $schoolYearRepository,
  45.         StudentYearRepository $studentYearRepository,
  46.         AbsenceRepository $absenceRepository,
  47.         SerializerInterface $serializer,
  48.         Request $request,
  49.         PaginatorInterface $paginator
  50.     ):JsonResponse
  51.     {
  52.         $user = $this->getUser();
  53.         $year = $schoolYearRepository->findOneBy(['active'=>true],[]);
  55.         $parentStudent = $studentYearRepository->findParentStudents($user, $this->getUser()->getSchool());
  57.         $studentsIds = [];
  58.         $userLateDetails = [];
  59.         foreach ($parentStudent as $value){
  60.             $studentsIds[] = $value->getStudent();
  61.             $studentAbsence = $absenceRepository->findBy(['student'=>$value,'year'=>$year], ['id' => 'DESC']);
  63.             $totalHrs = 0;
  64.             $totalJust = 0;
  65.             $totalInjust = 0;
  66.             foreach ($studentAbsence as $val){
  67.                 $totalHrs += $val->getDuration();
  68.                 $totalInjust += $val->getDuration() - $val->getJustified();
  69.                 $totalJust += $val->getJustified();
  70.             }
  71.             $absenceTotale = [
  72.                 'student' => [
  73.                     'id'=>$value->getStudent()->getId(),
  74.                     'firstName'=>$value->getStudent()->getFirstName(),
  75.                     'lastName'=>$value->getStudent()->getLastName()
  76.                 ],
  77.                 'totalHrs' =>$totalHrs,
  78.                 'totalInjust' => $totalInjust,
  79.                 'totalJust' => $totalJust
  80.             ];
  81.             $userLateDetails[] = $absenceTotale;
  82.         }
  84.         //dd($userLateDetails);
  86.         $parentAbsenceStudents = $absenceRepository->findAbsenceStudentsParent($studentsIds);
  88.         $data = $paginator->paginate($parentAbsenceStudents,
  89.             $request->query->getInt('page', 1),40);
  90.         $getData = [
  91.             'current_page_number'=>$data->getCurrentPageNumber(),
  92.             'number_per_page'=>$data->getItemNumberPerPage(),
  93.             'total_count'=>$data->getTotalItemCount(),
  94.             'total_absence_hrs'=>$userLateDetails,
  95.             'data'=>$data->getItems(),
  96.         ];
  98.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  99.         $jsonPost = $serializer->serialize($getData,'json',$context);
  101.         return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  103.     }
  107.      /**
  108.      * Absence parents index
  109.      * @OA\Tag(name="Absence")
  110.      */
  111.     #[Route("/api/parent/students/absences/classe/{classe}/",name: 'api_parent_absence_student_list_classe', methods: ['GET'])]
  112.     public function parentsGetAbsenceIndexClasse(
  113.         SchoolYearRepository $schoolYearRepository,
  114.         StudentYearRepository $studentYearRepository,
  115.         AbsenceRepository $absenceRepository,
  116.         SerializerInterface $serializer,
  117.         Request $request,
  118.         PaginatorInterface $paginator,
  119.         $classe,
  120.         TheClassRepository $theClassRepository
  121.     ):JsonResponse
  122.     {
  123.         $user = $this->getUser();
  124.         $year = $schoolYearRepository->findOneBy(['active'=>true],[]);
  125.         $classRepo = $theClassRepository->find($classe);
  126.         $parentStudent = $studentYearRepository->findBy(["classe"=>$classRepo, 'year'=>$year, 'school'=>$user->getSchool()]);
  128.         $studentsIds = [];
  129.         $userLateDetails = [];
  130.         foreach ($parentStudent as $value){
  131.             $studentsIds[] = $value->getStudent();
  132.             $studentAbsence = $absenceRepository->findBy(['student'=>$value,'year'=>$year], ['id' => 'DESC']);
  134.             $totalHrs = 0;
  135.             $totalJust = 0;
  136.             $totalInjust = 0;
  137.             foreach ($studentAbsence as $val){
  138.                 $totalHrs += $val->getDuration();
  139.                 $totalInjust += $val->getDuration() - $val->getJustified();
  140.                 $totalJust += $val->getJustified();
  141.             }
  142.             $absenceTotale = [
  143.                 'student' => [
  144.                     'id'=>$value->getStudent()->getId(),
  145.                     'firstName'=>$value->getStudent()->getFirstName(),
  146.                     'lastName'=>$value->getStudent()->getLastName()
  147.                 ],
  148.                 'totalHrs' =>$totalHrs,
  149.                 'totalInjust' => $totalInjust,
  150.                 'totalJust' => $totalJust
  151.             ];
  152.             $userLateDetails[] = $absenceTotale;
  153.         }
  155.         //dd($userLateDetails);
  157.         $parentAbsenceStudents = $absenceRepository->findBy(["classe"=>$classRepo, 'year'=>$year, 'school'=>$user->getSchool()], ['id' => 'DESC']);
  159.        
  161.         $data = $paginator->paginate($parentAbsenceStudents,
  162.             $request->query->getInt('page', 1),40);
  164.            // dd($data->getItems());
  166.         $resData = [];
  167.         foreach ($data as $item){
  168.             $absence = [];
  169.             $absence['id'] = $item->getId();
  171.             $studentAbsence = $absenceRepository->find($item->getId());
  172.             $absence['student'] = $studentAbsence ? [
  173.                 'id'=>$studentAbsence->getStudent()->getId(),
  174.                 'first_name'=>$studentAbsence->getStudent()->getFirstName(),
  175.                 'last_name'=>$studentAbsence->getStudent()->getLastName()
  176.             ] : null;
  177.             $absence['subject'] = [
  178.                 'id'=>$item->getSubject()->getId(),
  179.                 'name'=>$item->getSubject()->getName()
  180.             ];
  181.             $absence['start_time'] = $item->getStartTime();
  182.             $absence['end_time'] = $item->getEndTime();
  183.             $absence['absence_date'] = $item->getAbsenceDate();
  184.             $absence['duration'] = $item->getDuration();
  185.             $absence['created_at'] = $item->getCreatedAt();
  186.             $resData[] = $absence;
  187.         }
  189.         $getData = [
  190.             'current_page_number'=>$data->getCurrentPageNumber(),
  191.             'number_per_page'=>$data->getItemNumberPerPage(),
  192.             'total_count'=>$data->getTotalItemCount(),
  193.             'total_absence_hrs'=>$userLateDetails,
  194.             'data'=>$resData,
  195.         ];
  197.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  198.         $jsonPost = $serializer->serialize($getData,'json',$context);
  200.         return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  202.     }
  204.      /**
  205.      * Absence parents index
  206.      * @OA\Tag(name="Absence")
  207.      */
  208.     #[Route("/api/user/homework/students/classe/{classe}/",name: 'api_parent_absence_student_list_classe_student_exam', methods: ['GET'])]
  209.     public function studentClass(
  210.         SchoolYearRepository $schoolYearRepository,
  211.         StudentYearRepository $studentYearRepository,
  212.         ExamsRepository $examsRepository,
  213.         $classe,
  214.         TheClassRepository $theClassRepository,
  215.         SubjectRepository $subjectRepository,
  216.     ):JsonResponse
  217.     {
  218.         $user = $this->getUser();
  219.         $year = $schoolYearRepository->findOneBy(['active'=>true],[]);
  220.         $classRepo = $theClassRepository->find($classe);
  221.         $students = $studentYearRepository->findBy(["classe"=>$classRepo, 'year'=>$year, 'school'=>$user->getSchool()]);
  223.         $examsRepo = $examsRepository->findBy(['year'=>$year, 'school'=>$user->getSchool(), 'classe'=>$classRepo], ['id'=>'DESC']);
  224.         $examList = [];
  226.         foreach ($examsRepo as $exam){
  227.             $examList[] = [
  228.                 'id'=>$exam->getId(),
  229.                 'name'=>$exam->getName(),
  230.             ];
  231.         }
  233.         $studentList = [];
  234.         foreach ($students as $student) {
  235.             $studentList[] = [
  236.                 'id' => $student->getStudent()->getId(),
  237.                 'firstName' => $student->getStudent()->getFirstName(),
  238.                 'lastName' => $student->getStudent()->getLastName(),
  239.             ];
  240.         }
  242.         // Trier la liste des élèves par ordre alphabétique (lastName puis firstName)
  243.         usort($studentList, function($a, $b) {
  244.             $cmp = strcmp($a['lastName'], $b['lastName']);
  245.             if ($cmp === 0) {
  246.                 return strcmp($a['firstName'], $b['firstName']);
  247.             }
  248.             return $cmp;
  249.         });
  251.         $subjectRepo = $subjectRepository->findBy(['classe' => $classRepo, 'year' => $year, 'school' => $user->getSchool()], ['id' => 'DESC']);
  252.         $subjectList = [];
  253.         foreach ($subjectRepo as $subject) {
  254.             $subjectList[] = [
  255.                 'id' => $subject->getId(),
  256.                 'name' => $subject->getName(),
  257.             ];
  258.         }
  259.         //dd($subjectList);
  260.         $jsonPost = [
  261.             'classe' => [
  262.                 'id' => $classRepo->getId(),
  263.                 'name' => $classRepo->getName(),
  264.             ],
  265.             'examList' => $examList,
  266.             'studentList' => $studentList,
  267.             'subjectList' => $subjectList
  268.         ];
  269.         //dd($studentList);
  271.         return  $this->json($jsonPost);
  273.     }
  278.     /**
  279.      * Absence index
  280.      * @OA\Tag(name="Absence")
  281.      */
  282.     #[Route(path: '/api/absence/{id}/show', name: "api_absence_show",methods: ['GET'])]
  283.     public  function show(Absence $absence,SerializerInterface $serializer):JsonResponse
  284.     {
  285.         if (!$this->getUser()){
  286.             return new JsonResponse(
  287.                 $serializer->serialize(['message'=>'you must be logged'],'json'),
  288.                 Response::HTTP_UNAUTHORIZED,['accept'=>'application/json'],
  289.                 true
  290.             );
  291.         }
  292.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  293.         $jsonPost = $serializer->serialize($absence,'json',$context);
  295.         return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  296.     }
  300.     /**
  301.      * Add new Absence via API
  302.      * @OA\Tag(name="Absence")
  303.      */
  304.     #[Route('/api/prof/absence/new/user/{id}/', name: 'api_absence_add_user_', methods: ['POST'])]
  305.     public function apiAddAbsence(
  306.         $id,
  307.         SubjectRepository $subjectRepository,
  308.         StudentRepository $studentRepository,
  309.         Request $request,
  310.         EntityManagerInterface $entityManager,
  311.         SchoolYearRepository $schoolYearRepository,
  312.         ExamsRepository $examRepo,
  313.         PushNotificationService $notification,
  314.         SerializerInterface $serializer,
  315.         TheClassRepository $theClassRepository,
  316.         StudentYearRepository $studentYearRepository
  317.     ): JsonResponse
  318.     {
  319.         $data = $request->request->all();
  320.         $absence = new Absence();
  321.         $school = $this->getUser()->getSchool();
  322.         $year = $schoolYearRepository->findOneBy(["active"=>true],[]);
  323.        // $_student = $studentRepository->find($data["studentId"]);
  324.         
  325.         $subject = $subjectRepository->findOneBy(['id' => $data["subject"], 'school' => $school]);
  327.         $studentYear = $studentYearRepository->findOneBy(['student' => $id, 'year' => $year]);
  328.         $classe = $studentYear->getClasse();
  330.         //$theClassRepo = $theClassRepository->find($data["classe"]);
  331.         $exam = $examRepo->findOneBy(['id' => $data['exam'], 'school' => $school]);
  332.         $absence->setYear($year);
  333.         $absence->setStudent($studentYear->getStudent());
  334.         $absence->setDuration((float)$data["duration"]);
  335.         $absence->setSubject($subject);
  336.         $absence->setClasse($classe);
  337.         $absence->setSchool($school);
  338.         $absence->setAbsenceDate($data["lateDate"]);
  339.         $absence->setStartTime($data['normalTms']);
  340.         $absence->setEndTime($data['arriveTms']);
  341.         $absence->setExam($exam);
  342.         $absence->setAuthor($this->getUser());
  343.         //$this->getUser()->addAbsence($absence);
  345.         $entityManager->persist($absence);
  346.         $entityManager->persist($this->getUser());
  347.         $entityManager->flush();
  349.         
  350.         
  351.         $parent = $studentYear->getStudent()->getParent();
  352.         $_student = $studentYear->getStudent();
  353.         
  354.         if (!empty($parent)) {
  355.             $lang = $parent->getLocalPhoneLang();
  356.             $token = $parent->getUserToken();
  357.             $userId = $parent->getId();
  358.             $route = '/drawer/Absence';
  359.             $title = $lang == null ? 'Absence signalée' : 'Absence Signaled';
  360.             
  361.             if ($lang == null ) {
  362.                 $message = ($parent->getSexe() == 'M' ? 'Cher ' : 'Chère ')
  363.                     . $parent->getFullName()
  364.                     . ' votre enfant '
  365.                     . $_student->getFullName()
  366.                     . ' a été absent au cours de : '
  367.                     . $subject->getName()
  368.                     . ' du '
  369.                     . $absence->getAbsenceDate()
  370.                     . ' entre '
  371.                     . $absence->getStartTime()
  372.                     . ' et '
  373.                     . $absence->getEndTime();
  374.             } else {
  375.                 $message = ($parent->getSexe() == 'M' ? 'Dear ' : 'Dear ')
  376.                     . $parent->getFullName()
  377.                     . ' your child '
  378.                     . $_student->getFullName()
  379.                     . ' was absent in the course: '
  380.                     . $subject->getName()
  381.                     . ' on '
  382.                     . $absence->getAbsenceDate()
  383.                     . ' between '
  384.                     . $absence->getStartTime()
  385.                     . ' and '
  386.                     . $absence->getEndTime();
  387.             }
  389.             if ($token){
  390.                 $notificationUser = new UserNotifications;
  391.                 $notificationUser->setTitle($title);
  392.                 $notificationUser->setContent($message);
  393.                 $notificationUser->setUser($parent);
  394.                 $notificationUser->setExpoPushToken($token);
  395.                 $notificationUser->setType("absence");
  396.                 $entityManager->persist($notificationUser);
  398.                 $entityManager->flush();
  400.                 $notification->sendNotification($token, $title, $message, $route, $userId);
  401.             }
  403.         } 
  405.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  406.         $jsonPost = $serializer->serialize($absence,'json',$context);
  407.         return new JsonResponse($jsonPost, Response::HTTP_OK, ['accept'=>'application/json'], true);
  408.     }
  411.        /**
  412.      * Absence notifications
  413.      * @OA\Tag(name="Absence")
  414.      */
  415.     #[Route(path: '/api/absence/notification', name: "api_absence_notifications",methods: ['GET'])]
  416.     public function absenceNotification(
  417.         Request $request,
  418.         PaginatorInterface $paginator,
  419.         StudentYearRepository $studentYearRepository,
  420.         SerializerInterface $serializer,
  421.         SchoolYearRepository $schoolYearRepository,
  422.         StudentRepository $studentRepository,
  423.         AbsenceRepository $absenceRepository,
  424.         NotificationsRepository $notificationsRepository,
  425.         EntityManagerInterface $entityManager):JsonResponse
  426.     {
  427.         $user = $this->getUser();
  428.         $year = $schoolYearRepository->findOneBy(['active'=>true],[]);
  430.         $parentStudent = $studentYearRepository->findParentStudents($user, $this->getUser()->getSchool());
  432.         $studentsIds = [];
  433.         $userLateDetails = [];
  434.         foreach ($parentStudent as $value){
  435.             $studentsIds[] = $value->getStudent();
  436.             $studentAbsence = $absenceRepository->findBy(['student'=>$value,'year'=>$year]);
  438.             $totalHrs = 0;
  439.             $totalJust = 0;
  440.             $totalInjust = 0;
  441.             foreach ($studentAbsence as $val){
  442.                 $totalHrs += $val->getDuration();
  443.                 $totalInjust += $val->getDuration() - $val->getJustified();
  444.                 $totalJust += $val->getJustified();
  445.             }
  446.             $absenceTotale = [
  447.                 'student' => [
  448.                     'id'=>$value->getStudent()->getId(),
  449.                     'firstName'=>$value->getStudent()->getFirstName(),
  450.                     'lastName'=>$value->getStudent()->getLastName()
  451.                 ],
  452.                 'totalHrs' =>$totalHrs,
  453.                 'totalInjust' => $totalInjust,
  454.                 'totalJust' => $totalJust
  455.             ];
  456.             $userLateDetails[] = $absenceTotale;
  457.         }
  458.         //dd($userLateDetails);
  460.         $parentAbsenceStudents = $absenceRepository->findAbsenceStudentsParent($studentsIds);
  462.         $data = $paginator->paginate($parentAbsenceStudents,
  463.             $request->query->getInt('page', 1),40);
  464.         $notificationUserRow =  $notificationsRepository->findOneBy(['user'=>$user],[]);
  465.         if ($notificationUserRow == null){
  466.             $notif = new Notifications();
  467.             $notif->setUser($this->getUser());
  468.             $entityManager->persist($notif);
  469.             $entityManager->flush();
  470.         }
  471.         $absenceLastConnectionCount = $notificationsRepository->findOneBy(['user'=>$user],[]);
  473.         $absenceLastConnectionCountValue = $absenceLastConnectionCount->getAbsenceLastConnectionCount();
  474.         //if ($absenceLastConnectionCountValue !== null){
  475.         $absenceAdded = $data->getTotalItemCount() - $absenceLastConnectionCountValue;
  477.         if ($absenceAdded>1){
  479.             $updateNotif = $notificationsRepository->findOneBy(['user'=>$user],[]);
  480.             $updateNotif->setAbsenceLastConnectionCount($data->getTotalItemCount());
  481.             $entityManager->flush();
  483.             return new JsonResponse(
  484.                 $serializer->serialize(['title'=>'Absence(s)',"message" => $absenceAdded." Absences ont été ajoutée(s)" ],'json'),
  485.                 Response::HTTP_OK,['accept'=>'application/json'],
  486.                 true
  487.             );
  488.         }
  489.         return new JsonResponse(null, Response::HTTP_NO_CONTENT);
  491.     }
  493.  /**
  494.      * Absence index
  495.      * @OA\Tag(name="Absence")
  496.      */
  497.     #[Route("/v1/api/parent/absence/{from}",name: 'api_absence', methods: ['GET'])]
  498.     public function index(Request $request,
  499.        PaginatorInterface $paginator,
  500.        StudentYearRepository $studentYearRepository,
  501.        SerializerInterface $serializer,
  502.        SchoolYearRepository $schoolYearRepository,
  503.        StudentRepository $studentRepository,
  504.        AbsenceRepository $absenceRepository,
  505.        NotificationsRepository $notificationsRepository,
  506.        EntityManagerInterface $entityManager
  507.     ):JsonResponse
  508.     {
  509.         if (!$this->getUser()){
  510.              return new JsonResponse(
  511.                  $serializer->serialize(['message'=>'you must be logged'],'json'),
  512.                  Response::HTTP_UNAUTHORIZED,['accept'=>'application/json'],
  513.                  true
  514.              );
  515.         }
  517.         $year = $schoolYearRepository->findOneBy(["active"=>true]);
  518.         $user = $this->getUser();
  519.         //$students = $studentYearRepository->findBy(['year'=>$year]);
  520.         $school = $user->getSchool();
  521.         $_student = $studentYearRepository->findBy(['year'=>$year, 'school' => $school],['id'=>'DESc']);
  523.         
  524.         $parentStudents = $studentRepository->findByParent($user->getId(), $school->getId());
  526.         $absence = $absenceRepository->findBy(['year' => $year, 'school' => $school], ["id"=>'DESC']);
  527.         $absenceContent = [];
  528.         foreach ($absence as $value){
  529.             if (in_array($value->getStudent(), $parentStudents, true)){
  530.                 if ($value->getId() > $from) {
  531.                     $absenceContent[] = $value;
  532.                 }
  533.             }
  534.         }
  536.         $data = $paginator->paginate($absenceContent,
  537.             $request->query->getInt('page', 1),20);
  539.         $userLateDetails = [];
  540.         foreach ($parentStudents as $value){
  541.             $studentAbsence = $absenceRepository->findBy(['student' => $value,'year' => $year]);
  543.             $totalHrs = 0;
  544.             $totalJust = 0;
  545.             $totalInjust = 0;
  546.             foreach ($studentAbsence as $val){
  547.                 $totalHrs += $val->getDuration();
  548.                 $totalInjust += $val->getDuration() - $val->getJustified();
  549.                 $totalJust += $val->getJustified();
  550.             }
  551.             $absenceTotale = [
  552.                 'student' => $value,
  553.                 'totalHrs' =>$totalHrs,
  554.                 'totalInjust' => $totalInjust,
  555.                 'totalJust' => $totalJust
  556.             ];
  557.             $userLateDetails[] = $absenceTotale;
  558.         }
  560.         $getData = [
  561.             'current_page_number'=>$data->getCurrentPageNumber(),
  562.             'number_per_page'=>$data->getItemNumberPerPage(),
  563.             'total_count'=>$data->getTotalItemCount(),
  564.             'total_absence_hrs'=>$userLateDetails,
  565.             'data'=>$data->getItems(),
  566.         ];
  568.         $notificationUpdate = $notificationsRepository->findOneBy(['user'=>$user]);
  569.         if ($notificationUpdate === null){
  570.             $notification = new Notifications();
  571.             $notification->setUser($user);
  572.             $notification->setAbsenceLastConnectionCount($data->getTotalItemCount());
  573.             $entityManager->persist($notification);
  574.             $entityManager->flush();
  575.         }else{
  576.             $notificationUpdate->setAbsenceLastConnectionCount($data->getTotalItemCount());
  577.             $entityManager->flush();
  578.         }
  580.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  581.         $jsonAbsence = $serializer->serialize($getData,'json',$context);
  583.         return new JsonResponse($jsonAbsence,Response::HTTP_OK,['accept'=>'application/json'],true);
  584.     }
  586.     /**
  587.      * Absence notifications
  588.      * @OA\Tag(name="Absence")
  589.      */
  590.     #[Route("/v3/api/porter/absence/index/students/list",name: 'api_porter_absence_student_list', methods: ['GET'])]
  591.     public function getStudentListForAbsence(SchoolYearRepository $schoolYearRepository,
  592.         StudentYearRepository $studentYearRepository,
  593.         SerializerInterface $serializer
  594.     ):JsonResponse
  595.     {
  596.         $user = $this->getUser();
  598.         $school = $this->getUser()->getSchool();
  599.         $year =  $schoolYearRepository->findOneBy(['active'=>true]);
  601.         $students = $studentYearRepository->findBy(['school' => $school,'year' => $year]);
  603.         $context = SerializationContext::create()->setGroups(["getStudents"]);
  604.         $jsonStudents = $serializer->serialize($students,'json',$context);
  606.         return new JsonResponse($jsonStudents,Response::HTTP_OK,['accept'=>'application/json'],true);
  608.     }
  610.     /**
  611.      * Absence parents index
  612.      * @OA\Tag(name="Absence")
  613.      */
  614.     #[Route("/v3/api/parent/students/absences/from/{from}/list",name: 'api_parent_absence_student_list_', methods: ['GET'])]
  615.     public function parentsGetAbsence( $from,
  616.         SchoolYearRepository $schoolYearRepository,
  617.         StudentYearRepository $studentYearRepository,
  618.         AbsenceRepository $absenceRepository,
  619.         SerializerInterface $serializer
  620.     ):JsonResponse
  621.     {
  622.         $user = $this->getUser();
  623.         $year = $schoolYearRepository->findOneBy(['active'=>true],[]);
  625.         $parentStudent = $studentYearRepository->findParentStudents($user);
  627.         $studentsIds = [];
  628.         foreach ($parentStudent as $value){
  629.             $studentsIds[] = $value->getStudent();
  630.         }
  632.         $parentAbsenceStudents = $absenceRepository->findAbsenceStudents($from,$studentsIds);
  634.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  635.         $jsonPost = $serializer->serialize($parentAbsenceStudents,'json',$context);
  637.         return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  638.     }
  642.     /**
  643.      * Add new Absence
  644.      * @OA\Tag(name="Absence")
  645.      */
  646.     #[Route('/v3/api/prof/absence/new/user/{student}/', name: 'api_absence_add')]
  647.     public function addAbsence(
  648.         $student,
  649.         SubjectRepository $subjectRepository,
  650.         StudentRepository $studentRepository,
  651.         Request $request,
  652.         EntityManagerInterface $entityManager,
  653.         SchoolYearRepository $schoolYearRepository
  654.     ):Response
  655.     {
  656.         $absence = new Absence();
  657.         $year = $schoolYearRepository->findOneBy(["active"=>true], []);
  658.         $_student = $studentRepository->find($student);
  659.         $data = $request->request->all();
  660.         $subject = $subjectRepository->find($data["subject"]);
  661.         $absence->setYear($year);
  662.         $absence->setStudent($_student);
  663.         $absence->setDuration($data["duration"]);
  664.         $absence->setSubject($subject);
  665.         $absence->setAbsenceDate($data["lateDate"]);
  666.         $absence->setDuration((float)$data['duration']);
  667.         $absence->setStartTime($data['normalTms']);
  668.         $absence->setEndTime($data['arriveTms']);
  669.         $absence->setSchool($this->getUser()->getSchool());
  670.         $absence->setAuthor($this->getUser());
  671.         $this->getUser()->addAbsence($absence);
  673.         $entityManager->persist($absence);
  674.         $entityManager->persist($this->getUser());
  675.         $entityManager->flush();
  677.         $context = SerializationContext::create()->setGroups(["getAbsence"]);
  678.         $jsonPost = $serializer->serialize($absence,'json',$context);
  679.         return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  680.     }
  682.     #[Route('/api/admin/absence/{id}/remove', name:"api_absence_remove")]
  683.     public function remove(
  684.         Absence $absence,
  685.         EntityManagerInterface $entityManager,
  686.         Request $request
  687.     ):Response
  688.     {
  689.         $entityManager->remove($absence);
  691.         $entityManager->flush();
  693.         return new JsonResponse(null, Response::HTTP_NO_CONTENT);
  694.     }
  696.     /**
  697.      * Add new Absence
  698.      * @OA\Tag(name="Absence")
  699.      */
  700.     #[Route('/v3/api/prof/absence/justify/user/', name: 'api_absence_justify')]
  701.     public function justifyAbsence(
  702.         SubjectRepository $subjectRepository,
  703.         StudentRepository $studentRepository,
  704.         Request $request,
  705.         EntityManagerInterface $entityManager,
  706.         SchoolYearRepository $schoolYearRepository
  707.     ):Response
  708.     {
  709.         $data = $request->request->all();
  710.         $school = $this->getUser()->getSchool();
  711.         $absence = $absenceRepository->findOneBy(['id' => $data['absence'], 'school' => $school]);
  712.         $year = $schoolYearRepository->findOneBy(["active"=>true], []);
  713.         $_student = $studentRepository->findOneBy(['id' => $data['student'], 'school' => $school]);
  714.         $numberToJustify = $data['justify'];
  715.         $restToJustify = $absence->getDuration() - $absence->getJustified();
  716.         if ($numberToJustify <= $restToJustify) {
  717.             $absence->setJustified($absence->getJustified() + $numberToJustify);
  718.             $entityManager->persist($absence);
  719.             $entityManager->flush();
  721.             $context = SerializationContext::create()->setGroups(["getAbsence"]);
  722.             $jsonPost = $serializer->serialize($absence,'json',$context);
  723.             return new JsonResponse($jsonPost,Response::HTTP_OK,['accept'=>'application/json'],true);
  724.         } else {
  725.             return new JsonResponse(
  726.                 $serializer->serialize(['message'=>'le nombre total d\'absence a déjà été justifier'],'json'),
  727.                 Response::HTTP_UNAUTHORIZED,['accept'=>'application/json'],
  728.                 true
  729.             );
  730.         }
  731.     }
  733.     /*
  734.      * Absence parents  mercure hub subscribe
  735.      * @OA\Tag(name="Absence")
  736.      */
  737.     #[Route(path: '/v3/api/parent/{parent}/subscribe/absence/mercure/hub', name: 'api_parent_subscribe_mercure_hub', methods: ['GET'])]
  738.     public function getParentSubscribeMercureHub(
  739.         SerializerInterface $serializer,
  740.         Environment $twig,
  741.         $parent,
  742.         UserRepository $userRepository
  743.     ):JsonResponse
  744.     {
  745.         $_parent = $userRepository->find($parent);
  746.         $parentId = $_parent->getId();
  748.         $mercureHubSubscribeUrl = 'https://armsyschool.com/absence/page/hub/' . $parentId;
  750.         $result = $twig->render('mercure/client_hub_url.html.twig',[
  751.             'url'=>$mercureHubSubscribeUrl
  752.         ]);
  754.         return new  JsonResponse($serializer->serialize([ 'mercure_client_hub_url'=>$result], 'json'),Response::HTTP_OK,['accept'=>'application/json'],true);
  755.     }
  756. }