src/Controller/School/ReportCardController.php line 223

Open in your IDE?
  1. <?php
  3. namespace App\Controller\School;
  5. use Knp\Snappy\Pdf;
  6. use App\Entity\User;
  7. use App\Entity\ReportCard;
  8. use App\Entity\SchoolMatter;
  9. use App\Entity\SettingLevel;
  10. use App\Entity\SchoolReportCard;
  11. use App\Entity\SchoolYearPeriode;
  12. use App\Form\School\ReportCardType;
  13. use App\Entity\SchoolAverageReportCard;
  14. use App\Entity\SchoolReportCardAbsence;
  15. use App\Repository\ReportCardRepository;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use App\Form\School\SchoolReportCardType;
  18. use App\Service\StudentAverageCalculator;
  19. use App\Repository\SchoolMatterRepository;
  20. use App\Repository\SettingLevelRepository;
  21. use App\Repository\SchoolTeacherRepository;
  22. use Knp\Component\Pager\PaginatorInterface;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use App\Repository\SchoolMatterTypeRepository;
  25. use App\Repository\SchoolReportCardRepository;
  26. use App\Repository\SettingClassroomRepository;
  27. use Symfony\Component\HttpFoundation\Response;
  28. use App\Entity\RegistrationStudentRegistration;
  29. use App\Repository\SchoolYearPeriodeRepository;
  30. use Symfony\Component\Routing\Annotation\Route;
  31. use Doctrine\Common\Collections\ArrayCollection;
  32. use Symfony\Bridge\Doctrine\Form\Type\EntityType;
  33. use App\Repository\SchoolAbsenceAndDelayRepository;
  34. use App\Repository\SchoolAverageReportCardRepository;
  35. use App\Repository\SchoolReportCardAbsenceRepository;
  36. use App\Repository\SchoolAbsenceAndDelaySettingRepository;
  37. use App\Repository\RegistrationStudentRegistrationRepository;
  38. use App\Service\StudentAverageReportCardCalculator;
  39. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  40. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  41. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  42. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  43. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  45. /**
  46.  * @Route("/report/card")
  47.  */
  48. class ReportCardController extends AbstractController
  49. {
  50.     /**
  51.      * @Route("/index", name="report_card_index", methods={"GET"})
  52.      */
  53.     public function index(Request $request, PaginatorInterface $paginator, ReportCardRepository $reportCardRepository, SchoolTeacherRepository $schoolTeacherRepository): Response
  54.     {
  55.         /**@var User $user */
  56.         $user = $this->getUser();
  57.         $schoolYear = $user->getSchoolYear();
  59.         $establishment = $user->getEstablishment();
  60.         $schoolTeacher = $schoolTeacherRepository->findOneBy(['establishment' => $establishment, 'salary' => $user->getRhSalary()], []);
  62.         $report_cards = $paginator->paginate(
  63.             $reportCardRepository->createQueryBuilder('entity')
  65.             ->andWhere('entity.establishment = :establishment')
  66.             ->setParameter('establishment', $establishment)
  68.             ->andWhere('entity.schoolYear = :schoolYear')
  69.             ->setParameter('schoolYear', $schoolYear)
  71.             ->orderBy('entity.id', 'DESC')
  72.             ->getQuery(),
  73.             $request->query->getInt('page', 1),
  74.             1000
  75.         );
  77.         return $this->render('school/report_card/index.html.twig', [
  78.             'report_cards' => $report_cards,
  79.         ]);
  80.     }
  82.     /**
  83.      * @Route("/new", name="report_card_new", methods={"GET","POST"})
  84.      */
  85.     public function new(Request $request, SchoolYearPeriodeRepository $schoolYearPeriodeRepository, SettingLevelRepository $settingLevelRepository, ReportCardRepository $reportCardRepository, StudentAverageCalculator $studentAverageCalculator): Response
  86.     {
  87.         /**@var User $user */
  88.         $user = $this->getUser();
  89.         $schoolYear = $user->getSchoolYear();
  90.         $establishment = $user->getEstablishment();
  92.         $schoolYearPeriodes = $schoolYearPeriodeRepository->findBy(['schoolYear' => $schoolYear, 'establishment' => $establishment, 'is_closed' => 0]);
  93.         $levels = $settingLevelRepository->findBy(['establishment' => $establishment], ['label' => 'ASC']);
  95.         $reportCard = new ReportCard();
  96.         $form = $this->createForm(ReportCardType::class, $reportCard)
  97.         ->add('schoolYearPeriode', EntityType::class, [
  98.             'class' => SchoolYearPeriode::class,
  99.             'choices' => $schoolYearPeriodes,
  100.             'required' => true
  101.         ])
  102.         ->add('level', EntityType::class, [
  103.             'class' => SettingLevel::class,
  104.             'choices' => $levels,
  105.             'required' => true
  106.         ]);
  107.         $form->handleRequest($request);
  109.         if ($form->isSubmitted() && $form->isValid()) {
  110.             $entityManager = $this->getDoctrine()->getManager();
  111.             if (null != $reportCardRepository->findOneBy(['schoolYearPeriode' => $reportCard->getSchoolYearPeriode(), 'level' => $reportCard->getLevel()], [])) {
  112.                 $this->addFlash('warning', "Ce bulletin existe déjà.");
  113.                 return $this->redirectToRoute('report_card_new');
  114.             }
  116.             $reportCard->setEstablishment($establishment);
  117.             $reportCard->setSchoolYear($schoolYear);
  118.             $reportCard->setCode('B'.rand(100000, 999999).$reportCard->getSchoolYearPeriode()->getId().$reportCard->getLevel()->getId());
  119.             $reportCard->setCoefficient($reportCard->getSchoolYearPeriode()->getCoefficient());
  121.             foreach ($reportCard->getLevel()->getSettingClassrooms() as $key => $classroom) {
  122.                 if ($classroom->getSchoolYear() == $schoolYear) {
  123.                     $index = 1;
  124.                     foreach ($classroom->getRegistereds($schoolYear) as $key => $registrationStudentRegistration) {
  125.                         if (!$registrationStudentRegistration->isAbandonne()) {
  126.                             $schoolReportCard = new SchoolReportCard();
  127.                             $schoolReportCard->setClassroom($classroom);
  128.                             $schoolReportCard->setCode('BE'.$reportCard->getCode().$registrationStudentRegistration->getId());
  129.                             $schoolReportCard->setCoefficient($reportCard->getCoefficient());
  130.                             $schoolReportCard->setEstablishment($establishment);
  131.                             $schoolReportCard->setLabel($reportCard->getLabel());
  132.                             $schoolReportCard->setOrderNum($index);
  133.                             $schoolReportCard->setReportCard($reportCard);
  134.                             $schoolReportCard->setNoteOn($reportCard->getNoteOn());
  135.                             $schoolReportCard->setSchoolYear($schoolYear);
  136.                             $schoolReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  137.                             $schoolReportCard->setStudentRegistration($registrationStudentRegistration);
  138.                             $schoolReportCard->setType('normal');
  139.                             $entityManager->persist($schoolReportCard);
  140.                             foreach ($classroom->getLevel()->getSchoolMatters() as $key => $matter) {
  141.                                 if (!$matter->getIsTestMatter()) {
  142.                                     if ($matter->getNoteOnReportCard() <= 0) {
  143.                                         $this->addFlash('warning', "Veuillez configurer correctement la matière: ".$matter->getLabel()." 'Noté sur Bulletin' doit être defini.");
  144.                                         return $this->redirectToRoute('report_card_new');
  145.                                     }
  147.                                     if ($schoolReportCard->getStudentRegistration()->asMatterDone($matter, $reportCard)) {
  148.                                         $schoolAverageReportCard = new SchoolAverageReportCard();
  149.                                         $schoolAverageReportCard->setCode('MY'.$schoolReportCard->getCode().$matter->getId());
  150.                                         //$schoolAverageReportCard->setAverage($schoolReportCard->getStudentRegistration()->computePeriodeAverage($matter, $reportCard, $schoolAverageReportCard));
  151.                                         $schoolAverageReportCard->setAverage($studentAverageCalculator->calculateSubjectAverage($registrationStudentRegistration, $matter, $reportCard->getSchoolYearPeriode()));
  152.                                         $schoolAverageReportCard->setClassroom($classroom);
  153.                                         $schoolAverageReportCard->setCoefficient($matter->getCoefficient());
  154.                                         $schoolAverageReportCard->setCoefficientXAverage($schoolAverageReportCard->getAverage() * $schoolAverageReportCard->getCoefficient());
  155.                                         $schoolAverageReportCard->setEstablishment($establishment);
  156.                                         $schoolAverageReportCard->setMatter($matter);
  157.                                         $schoolAverageReportCard->setIsMatterConduct($matter->getIsMatterConduct());
  158.                                         $schoolAverageReportCard->setNoteOn($matter->getNoteOnReportCard());
  159.                                         $schoolAverageReportCard->setOrderNum($matter->getOrderNum());
  160.                                         $schoolAverageReportCard->setReportCard($schoolReportCard);
  161.                                         $schoolAverageReportCard->setSchoolYear($schoolYear);
  162.                                         $schoolAverageReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  163.                                         $schoolAverageReportCard->setStudentRegistration($registrationStudentRegistration);
  164.                                         $countSubMatters = 0;
  165.                                         foreach ($matter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  166.                                             $schoolAverageReportCard->setAsSubmatter(true);
  167.                                             //if ($schoolReportCard->getStudentRegistration()->asMatterDone($matter, $reportCard)) {
  168.                                                 $schoolSubAverageReportCard = new SchoolAverageReportCard();
  169.                                                 $schoolSubAverageReportCard->setCode('SMY'.$schoolReportCard->getCode().$schoolSubMatter->getId());
  170.                                                 //$schoolSubAverageReportCard->setAverage($schoolReportCard->getStudentRegistration()->computeSubPeriodeAverage($schoolSubMatter, $reportCard, $schoolAverageReportCard));
  171.                                                 $schoolSubAverageReportCard->setAverage($studentAverageCalculator->calculateSubMatterAverage($registrationStudentRegistration, $schoolSubMatter, $reportCard->getSchoolYearPeriode()));
  172.                                                 $schoolSubAverageReportCard->setClassroom($classroom);
  173.                                                 $schoolSubAverageReportCard->setCoefficient($schoolSubMatter->getCoefficient());
  174.                                                 $schoolSubAverageReportCard->setCoefficientXAverage($schoolSubAverageReportCard->getAverage() * $schoolSubAverageReportCard->getCoefficient());
  175.                                                 $schoolSubAverageReportCard->setEstablishment($establishment);
  176.                                                 $schoolSubAverageReportCard->setMatter($matter);
  177.                                                 $schoolSubAverageReportCard->setIsMatterConduct($matter->getIsMatterConduct());
  178.                                                 $schoolSubAverageReportCard->setSubMatter($schoolSubMatter);
  179.                                                 $schoolSubAverageReportCard->setNoteOn($schoolSubMatter->getNotedOn());
  180.                                                 $schoolSubAverageReportCard->setOrderNum($matter->getOrderNum());
  181.                                                 $schoolSubAverageReportCard->setReportCard($schoolReportCard);
  182.                                                 $schoolSubAverageReportCard->setSchoolYear($schoolYear);
  183.                                                 $schoolSubAverageReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  184.                                                 $schoolSubAverageReportCard->setStudentRegistration($registrationStudentRegistration);
  185.                                                 $entityManager->persist($schoolSubAverageReportCard);
  186.                                             //}
  187.                                         }
  189.                                         //if ($countSubMatters <= 0) {
  190.                                             $entityManager->persist($schoolAverageReportCard);
  191.                                         //}
  192.                                     }
  193.                                 }
  194.                             }
  196.                             $index++;
  197.                         }
  198.                     }
  199.                 }
  200.             }
  201.             $entityManager->persist($reportCard);
  202.             try {
  203.                 $entityManager->flush();
  204.                 $this->addFlash('success', "Enrégistrement effectué.");
  205.             } catch (\Throwable $th) {
  206.                 $this->addFlash('warning', "Une erreure est survenue lors de l'ajout de la classe.");
  207.                 $this->addFlash('info', $th->getMessage());
  208.                 return $this->redirectToRoute('report_card_new');
  209.             }
  211.             return $this->redirectToRoute('report_card_edit', ['id' => $reportCard->getId()]);
  212.         }
  214.         return $this->renderForm('school/report_card/new.html.twig', [
  215.             'report_card' => $reportCard,
  216.             'form' => $form,
  217.         ]);
  218.     }
  220.     /**
  221.      * @Route("/{id}/edit", name="report_card_edit", methods={"GET","POST"})
  222.      */
  223.     public function edit(Request $request, StudentAverageReportCardCalculator $studentAverageReportCardCalculator, StudentAverageCalculator $studentAverageCalculator, SchoolReportCardAbsenceRepository $schoolReportCardAbsenceRepository, ReportCard $reportCard, RegistrationStudentRegistrationRepository $registrationStudentRegistrationRepository, SchoolReportCardRepository $schoolReportCardRepository): Response
  224.     {
  225.          /**@var User $user */
  226.          $user = $this->getUser();
  227.          $schoolYear = $user->getSchoolYear();
  229.         $establishment = $user->getEstablishment();
  231.         $registrationStudentRegistrations = $registrationStudentRegistrationRepository->createQueryBuilder('entity')
  232.         ->innerJoin('entity.classroom', 'classroom')
  233.         ->addSelect('classroom')
  235.         ->innerJoin('entity.student', 'student')
  236.         ->addSelect('student')
  238.         ->andWhere('classroom.level = :level')
  239.         ->setParameter('level', $reportCard->getLevel())
  241.         ->andWhere('entity.establishment = :establishment')
  242.         ->setParameter('establishment', $establishment)
  244.         ->andWhere('entity.status != :status')
  245.         ->setParameter('status', RegistrationStudentRegistration::STATUS_ABANDONNE)
  247.         ->orderBy('student.last_name', 'ASC')
  248.         ->getQuery()
  249.         ->getResult();
  251.         $entityManager = $this->getDoctrine()->getManager();
  253.         $form = $this->createForm(ReportCardType::class, $reportCard);
  254.         $form->handleRequest($request);
  256.         if ($form->isSubmitted() && $form->isValid()) {
  257.             try {
  258.                 $entityManager->flush();
  259.                 $this->addFlash('success', "Enrégistrement effectué.");
  260.             } catch (\Throwable $th) {
  261.                 $this->addFlash('warning', "Une erreure est survenue lors de l'ajout de la classe.");
  262.                 $this->addFlash('info', $th->getMessage());
  263.                 
  264.             }
  266.             return $this->redirectToRoute('report_card_edit', ['id' => $reportCard->getId()]);
  267.         }
  269.         $schoolReportCard = new SchoolReportCard();
  270.         
  271.         $schoolReportCardForm = $this->createForm(SchoolReportCardType::class, $schoolReportCard)
  272.         
  273.         ->add('studentRegistration', EntityType::class, [
  274.             'class' => RegistrationStudentRegistration::class,
  275.             'choices' => $registrationStudentRegistrations
  276.         ])
  277.         ->remove('coefficient')
  278.         ->remove('note_on');
  279.         $schoolReportCardForm->handleRequest($request);
  281.         if ($schoolReportCardForm->isSubmitted() && $schoolReportCardForm->isValid()) {
  282.             $entityManager = $this->getDoctrine()->getManager();
  283.             $schoolReportCard->setEstablishment($establishment);
  284.             $schoolReportCard->setSchoolYear($schoolYear);
  285.             $schoolReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  286.             $schoolReportCard->setClassroom($schoolReportCard->getStudentRegistration()->getClassroom());
  287.             $schoolReportCard->setReportCard($reportCard);
  288.             $schoolReportCard->setNoteOn($reportCard->getNoteOn());
  289.             $schoolReportCard->setCoefficient($reportCard->getCoefficient());
  290.             $schoolReportCard->setCode('BE'.$reportCard->getCode().$schoolReportCard->getStudentRegistration()->getId());
  291.             $schoolReportCard->setLabel($reportCard->getLabel());
  292.             $schoolReportCard->setOrderNum($reportCard->getOrderNum());
  293.             $schoolReportCard->setType("normal");
  294.             
  295.             foreach ($schoolReportCard->getClassroom()->getLevel()->getSchoolMatters() as $key => $matter) {
  296.                 if ($schoolReportCard->getStudentRegistration()->asMatterDone($matter, $reportCard)) {
  297.                     $schoolAverageReportCard = new SchoolAverageReportCard();
  298.                     $schoolAverageReportCard->setCode('MY'.$schoolReportCard->getCode().$matter->getId());
  299.                     //$schoolAverageReportCard->setAverage($schoolReportCard->getStudentRegistration()->computePeriodeAverage($matter, $reportCard, $schoolAverageReportCard));
  300.                     $schoolAverageReportCard->setAverage($studentAverageCalculator->calculateSubjectAverage($schoolReportCard->getStudentRegistration(), $matter, $reportCard->getSchoolYearPeriode()));
  301.                     $schoolAverageReportCard->setClassroom($schoolReportCard->getClassroom());
  302.                     $schoolAverageReportCard->setCoefficient($matter->getCoefficient());
  303.                     $schoolAverageReportCard->setCoefficientXAverage($schoolAverageReportCard->getAverage() * $schoolAverageReportCard->getCoefficient());
  304.                     $schoolAverageReportCard->setEstablishment($establishment);
  305.                     $schoolAverageReportCard->setMatter($matter);
  306.                     $schoolAverageReportCard->setIsMatterConduct($matter->getIsMatterConduct());
  307.                     $schoolAverageReportCard->setNoteOn($matter->getNotedOn());
  308.                     $schoolAverageReportCard->setOrderNum($matter->getOrderNum());
  309.                     $schoolAverageReportCard->setReportCard($schoolReportCard);
  310.                     $schoolAverageReportCard->setSchoolYear($schoolYear);
  311.                     $schoolAverageReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  312.                     $schoolAverageReportCard->setStudentRegistration($schoolReportCard->getStudentRegistration());
  313.                     $countSubMatters = 0;
  314.                     foreach ($matter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  315.                         $schoolAverageReportCard->setAsSubmatter(true);
  316.                         //if ($schoolReportCard->getStudentRegistration()->asMatterDone($matter, $reportCard)) {
  317.                             $schoolSubAverageReportCard = new SchoolAverageReportCard();
  318.                             $schoolSubAverageReportCard->setCode('SMY'.$schoolReportCard->getCode().$schoolSubMatter->getId());
  319.                             //$schoolSubAverageReportCard->setAverage($schoolReportCard->getStudentRegistration()->computeSubPeriodeAverage($schoolSubMatter, $reportCard, $schoolAverageReportCard));
  320.                             $schoolSubAverageReportCard->setAverage($studentAverageCalculator->calculateSubMatterAverage($schoolReportCard->getStudentRegistration(), $schoolSubMatter, $reportCard->getSchoolYearPeriode()));
  321.                             $schoolSubAverageReportCard->setClassroom($schoolReportCard->getClassroom());
  322.                             $schoolSubAverageReportCard->setCoefficient($schoolSubMatter->getCoefficient());
  323.                             $schoolSubAverageReportCard->setCoefficientXAverage($schoolSubAverageReportCard->getAverage() * $schoolSubAverageReportCard->getCoefficient());
  324.                             $schoolSubAverageReportCard->setEstablishment($establishment);
  325.                             $schoolSubAverageReportCard->setMatter($matter);
  326.                             $schoolSubAverageReportCard->setIsMatterConduct($matter->getIsMatterConduct());
  327.                             $schoolSubAverageReportCard->setSubMatter($schoolSubMatter);
  328.                             $schoolSubAverageReportCard->setNoteOn($schoolSubMatter->getNotedOn());
  329.                             $schoolSubAverageReportCard->setOrderNum($matter->getOrderNum());
  330.                             $schoolSubAverageReportCard->setReportCard($schoolReportCard);
  331.                             $schoolSubAverageReportCard->setSchoolYear($schoolYear);
  332.                             $schoolSubAverageReportCard->setSchoolYearPeriode($reportCard->getSchoolYearPeriode());
  333.                             $schoolSubAverageReportCard->setStudentRegistration($schoolReportCard->getStudentRegistration());
  334.                             $entityManager->persist($schoolSubAverageReportCard);
  335.                         //}
  336.                     }
  338.                     //if ($countSubMatters <= 0) {
  339.                         $entityManager->persist($schoolAverageReportCard);
  340.                     //}
  341.                 }
  342.             }
  343.             
  344.             $entityManager->persist($schoolReportCard);
  345.             try {
  346.                 $entityManager->flush();
  347.                 $this->addFlash('success', "Enrégistrement effectué.");
  348.             } catch (\Throwable $th) {
  349.                 $this->addFlash('warning', "Une erreure est survenue lors de l'ajout de la classe.");
  350.                 $this->addFlash('info', $th->getMessage());
  351.             }
  353.             return $this->redirectToRoute('report_card_edit', ['id' => $reportCard->getId()]);
  354.         }
  356.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  357.         ->innerJoin('entity.studentRegistration', 'studentRegistration')
  358.         ->addSelect('studentRegistration')
  360.         ->innerJoin('studentRegistration.student', 'student')
  361.         ->addSelect('student')
  363.         ->andWhere('entity.reportCard = :reportCard')
  364.         ->setParameter('reportCard', $reportCard)
  365.         
  366.         ->orderBy('student.first_name', 'ASC')
  367.         ->orderBy('student.last_name', 'ASC')
  368.         ->getQuery()
  369.         ->getResult();
  371.         $school_report_cards = new ArrayCollection();
  372.         foreach ($schoolReportCards as $key => $schoolReportCard) {
  373.             //dd($studentAverageReportCardCalculator->calculateClassStatistics($schoolReportCard->getClassroom(), $reportCard));
  374.             if (!$reportCard->getIsValidated()) {
  375.                 foreach ($schoolReportCard->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  376.                     // Vérifier si c'est une sous-matière ou une matière principale
  377.                     if ($schoolAverageReportCard->getSubMatter() !== null) {
  378.                         // C'est une sous-matière, calculer sa moyenne spécifique
  379.                         $schoolAverageReportCard->setAverage($studentAverageCalculator->calculateSubMatterAverage($schoolReportCard->getStudentRegistration(), $schoolAverageReportCard->getSubMatter(), $reportCard->getSchoolYearPeriode()));
  380.                     } else {
  381.                         // C'est une matière principale, calculer sa moyenne
  382.                         $schoolAverageReportCard->setAverage($studentAverageCalculator->calculateSubjectAverage($schoolReportCard->getStudentRegistration(), $schoolAverageReportCard->getMatter(), $reportCard->getSchoolYearPeriode()));
  383.                     }
  384.                     
  385.                 }
  386.                 $schoolReportCard->setReportCardAverage($studentAverageReportCardCalculator->calculateGeneralAverage($schoolReportCard));
  387.                 $schoolReportCard->setTotalAverage($studentAverageReportCardCalculator->calculateTotalAverage($schoolReportCard));
  388.                 $schoolReportCard->setTotalCoefficient($studentAverageReportCardCalculator->calculateTotalCoefficient($schoolReportCard));
  389.                 $schoolReportCard->setSmallestAverage($studentAverageReportCardCalculator->calculateClassStatistics($schoolReportCard->getClassroom(), $reportCard)['min_average']);
  390.                 $schoolReportCard->setSstrongestAverage($studentAverageReportCardCalculator->calculateClassStatistics($schoolReportCard->getClassroom(), $reportCard)['max_average']);
  391.                 $schoolReportCard->setClassAverage($studentAverageReportCardCalculator->calculateClassStatistics($schoolReportCard->getClassroom(), $reportCard)['class_average']);
  392.                 
  393.                 $schoolReportCardAbsence = $studentAverageReportCardCalculator->calculateAbsences($schoolReportCard->getStudentRegistration(), $reportCard);
  394.                 $schoolReportCard->setUnjustifiedAbsence($schoolReportCardAbsence['unjustified_absence']);
  395.                 $schoolReportCard->setJustifiedAbsence($schoolReportCardAbsence['justified_absence']);
  397.                 // $schoolReportCardAbsence = $schoolReportCardAbsenceRepository->findOneBy(['schoolYearPeriode' => $reportCard->getSchoolYearPeriode(), 'studentRegistration' => $schoolReportCard->getStudentRegistration()], []);
  398.                 //if (null != $schoolReportCardAbsence) {
  399.                 //    $schoolReportCard->setUnjustifiedAbsence($schoolReportCardAbsence->getUnjustifiedAbsence());
  400.                 //    $schoolReportCard->setJustifiedAbsence($schoolReportCardAbsence->getJustifiedAbsence());
  401.                 //} 
  402.             }
  404.             $school_report_cards->add([
  405.                 'id' => $schoolReportCard->getId(),
  406.                 'code' => $schoolReportCard->getStudentRegistration()->getStudent()->getRegistrationNumber(),
  407.                 'name' => $schoolReportCard->getStudentRegistration()->getStudent()->getName(),
  408.                 'classroom' => $schoolReportCard->getStudentRegistration()->getClassroom()->getLabel(),
  409.                 'reportCardAverage' => $schoolReportCard->getReportCardAverage(),
  410.                 'isValidated' => $schoolReportCard->getIsValidated(),
  411.                 'isUnclassified' => $schoolReportCard->isUnclassified(),
  412.                 
  413.             ]);
  414.         }
  416.         try {
  417.             $entityManager = $this->getDoctrine()->getManager();
  418.             $entityManager->flush();
  419.         } catch (\Throwable $th) {
  420.             //throw $th;
  421.         }
  423.         $school_report_cards_array = $school_report_cards->toArray();
  424.         uasort($school_report_cards_array, function ($first, $second) {
  425.             if ($first === $second) {
  426.                 return 0;
  427.             }
  429.             return $first['name'] < $second['name'] ? -1 : 1;
  430.         });
  431.         $school_report_cards = new ArrayCollection($school_report_cards_array);
  433.         return $this->renderForm('school/report_card/edit.html.twig', [
  434.             'school_report_cards' => $school_report_cards,
  435.             'report_card' => $reportCard,
  436.             'form' => $form,
  438.             'school_report_card' => $schoolReportCard,
  439.             'school_report_card_form' => $schoolReportCardForm,
  440.         ]);
  441.     }
  443.     /**
  444.      * @Route("/delete-selection", name="report_cards_selected_delete", methods={"GET"})
  445.     */
  446.     public function deleteSelected(Request $request, ReportCardRepository $entityRepository): Response
  447.     {
  448.         $list = $request->get('entities');
  449.         $entityManager = $this->getDoctrine()->getManager();
  450.         $errors = 0;
  451.         $success = 0;
  452.         foreach ($list as $key => $id) {
  453.             $entity = $entityRepository->findOneBy(['id' => intval($id)], []);
  454.             if ($entity != null) {
  455.                 if (!$entity->getIsValidated()) {
  456.                     foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  457.                         foreach ($schoolReportCard->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  458.                             $entityManager->remove($schoolAverageReportCard);
  459.                         }
  461.                         foreach ($schoolReportCard->getSchoolAssessmentByClassByMatters() as $key => $schoolAssessmentByClassByMatter) {
  462.                             $entityManager->remove($schoolAssessmentByClassByMatter);
  463.                         }
  465.                         foreach ($schoolReportCard->getSchoolAssessmentByClasses() as $key => $schoolAssessmentByClasse) {
  466.                             $entityManager->remove($schoolAssessmentByClasse);
  467.                         }
  469.                         foreach ($schoolReportCard->getSchoolAssessmentByLevelByMatters() as $key => $schoolAssessmentByLevelByMatter) {
  470.                             $entityManager->remove($schoolAssessmentByLevelByMatter);
  471.                         }
  473.                         foreach ($schoolReportCard->getSchoolAssessmentByLevels() as $key => $schoolAssessmentByLevel) {
  474.                             $entityManager->remove($schoolAssessmentByLevel);
  475.                         }
  477.                         $entityManager->remove($schoolReportCard);
  478.                     }
  480.                     foreach ($entity->getSchoolAssessments() as $key => $schoolAssessmentByLevel) {
  481.                         $entityManager->remove($schoolAssessmentByLevel);
  482.                     }
  483.                     
  484.                     $entityManager->remove($entity);
  485.                     $success++;
  486.                 }else {
  487.                     $errors++;
  488.                 }
  489.             }else {
  490.                 $errors++;
  491.             }
  492.         }
  494.         try {
  495.             $entityManager->flush();
  496.             $this->addFlash('success', $success." éléments on été supprimés");
  497.             return $this->json(['code' => 200, 'message' => $success." éléments on été supprimés"], 200);
  498.         } catch (\Throwable $th) {
  499.             //$th->getMessage()
  500.             $this->addFlash('warning', $th->getMessage());
  501.         }
  502.         
  503.         $this->addFlash('warning', "Traitement non effectué");
  504.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  505.     }
  507.     /**
  508.      * @Route("/{id}/validate", name="report_card_validate", methods={"GET"})
  509.     */
  510.     public function validate(ReportCard $entity): Response
  511.     {
  512.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  513.            $schoolReportCard->setIsValidated(true);
  514.         }
  515.         
  516.         $entityManager = $this->getDoctrine()->getManager();
  517.         $entity->setIsValidated(true);
  519.         try {
  520.             $entityManager->flush();
  521.             $this->addFlash('success', "Traitement effectué");
  522.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  523.         } catch (\Throwable $th) {
  524.             $this->addFlash('warning', $th->getMessage());
  525.         }
  526.         
  527.         $this->addFlash('warning', "Traitement non effectué");
  528.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  529.     }
  531.     /**
  532.      * @Route("/{id}/cancel", name="report_card_cancel", methods={"GET"})
  533.     */
  534.     public function cancel(ReportCard $entity): Response
  535.     {
  536.         $entityManager = $this->getDoctrine()->getManager();
  537.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  538.             $schoolReportCard->setIsValidated(false);
  539.          }
  540.         $entity->setIsValidated(false);
  541.             
  542.         try {
  543.             $entityManager->flush();
  544.             $this->addFlash('success', "Traitement effectué");
  545.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  546.         } catch (\Throwable $th) {
  547.             $this->addFlash('warning', $th->getMessage());
  548.         }
  549.         
  550.         $this->addFlash('warning', "Traitement non effectué");
  551.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  552.     }
  554.     /**
  555.      * @Route("/{id}/compute-conduct-average", name="report_card_compute_conduct_average", methods={"GET"})
  556.     */
  557.     public function computeConductAverage(ReportCard $entity, SchoolAbsenceAndDelayRepository $schoolAbsenceAndDelayRepository, SchoolAbsenceAndDelaySettingRepository $schoolAbsenceAndDelaySettingRepository): Response
  558.     {
  559.         $entityManager = $this->getDoctrine()->getManager();
  560.         $schoolAbsenceAndDelaySetting = $schoolAbsenceAndDelaySettingRepository->findOneBy(['establishment' => $entity->getEstablishment()], []);
  561.         //calcule des moyenne de conduite
  562.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  563.             if (!$schoolReportCard->getIsValidated()) {
  564.                 if ($entity->getEstablishment()->getType() != $entity->getEstablishment()::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES){
  565.                     $justifiedAbsence = $schoolAbsenceAndDelayRepository->createQueryBuilder('entity')
  566.                     ->andWhere('entity.schoolYearPeriode = :schoolYearPeriode')
  567.                     ->setParameter('schoolYearPeriode', $schoolReportCard->getSchoolYearPeriode())
  569.                     ->andWhere('entity.studentRegistration = :studentRegistration')
  570.                     ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  572.                     ->andWhere('entity.situation = :situation')
  573.                     ->setParameter('situation', 'ABSENCE')
  575.                     ->andWhere('entity.duration_type = :duration_type')
  576.                     ->setParameter('duration_type', 'HEURE')
  578.                     ->andWhere('entity.is_justify = :is_justify')
  579.                     ->setParameter('is_justify', 1)
  581.                     ->select('SUM(entity.duration)')
  582.                     ->getQuery()
  583.                     ->getSingleScalarResult();
  585.                     $unJustifiedAbsence = $schoolAbsenceAndDelayRepository->createQueryBuilder('entity')
  586.                     ->andWhere('entity.schoolYearPeriode = :schoolYearPeriode')
  587.                     ->setParameter('schoolYearPeriode', $schoolReportCard->getSchoolYearPeriode())
  589.                     ->andWhere('entity.studentRegistration = :studentRegistration')
  590.                     ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  592.                     ->andWhere('entity.situation = :situation')
  593.                     ->setParameter('situation', 'ABSENCE')
  595.                     ->andWhere('entity.duration_type = :duration_type')
  596.                     ->setParameter('duration_type', 'HEURE')
  598.                     ->andWhere('entity.is_justify = :is_justify')
  599.                     ->setParameter('is_justify', 0)
  601.                     ->select('SUM(entity.duration)')
  602.                     ->getQuery()
  603.                     ->getSingleScalarResult();
  605.                     $schoolReportCard->setJustifiedAbsence($justifiedAbsence);
  606.                     $schoolReportCard->setUnJustifiedAbsence($unJustifiedAbsence);
  607.                 }
  608.             }
  609.         }
  611.         try {
  612.             $entityManager->flush();
  613.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  614.         } catch (\Throwable $th) {
  615.             $this->addFlash('warning', $th->getMessage());
  616.         }
  617.         
  618.         $this->addFlash('warning', "Traitement non effectué");
  619.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  620.     }
  622.     /**
  623.      * @Route("/{id}/compute-average", name="report_card_compute_average", methods={"GET"})
  624.     */
  625.     public function computeAverage(ReportCard $entity, SchoolAverageReportCardRepository $schoolAverageReportCardRepository): Response
  626.     {
  627.         $entityManager = $this->getDoctrine()->getManager();
  628.         //calcule des moyenne
  629.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  630.             if (!$schoolReportCard->getIsValidated()) {
  631.                 if ($entity->getEstablishment()->getType() == $entity->getEstablishment()::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES){
  632.                     $reportCardAverage = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  633.                     ->innerJoin('entity.reportCard', 'reportCard')
  634.                     ->addSelect('reportCard')
  636.                     ->andWhere('entity.reportCard = :reportCard')
  637.                     ->setParameter('reportCard', $schoolReportCard)
  639.                     ->andWhere('entity.average < :average')
  640.                     ->setParameter('average', 999)
  642.                     //->select('SUM(entity.average * (entity.note_on / reportCard.note_on)) / (SUM(entity.note_on / reportCard.note_on))')
  643.                     ->select('SUM(entity.average) / (SUM(entity.note_on / reportCard.note_on))')
  644.                     ->getQuery()
  645.                     ->getSingleScalarResult();
  647.                     $schoolReportCard->setReportCardAverage($reportCardAverage);
  648.                 }else {
  649.                     $sumAverages = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  650.                     ->innerJoin('entity.matter', 'matter')
  651.                     ->addSelect('matter')
  653.                     ->andWhere('entity.reportCard = :reportCard')
  654.                     ->setParameter('reportCard', $schoolReportCard)
  656.                     ->andWhere('entity.average != :average')
  657.                     ->setParameter('average', 999)
  659.                     ->andWhere('entity.as_submatter = :as_submatter')
  660.                     ->setParameter('as_submatter', 0)
  662.                     ->select('SUM(entity.average * entity.coefficient)')
  663.                     ->getQuery()
  664.                     ->getSingleScalarResult();
  666.                     $sumCoefficients = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  667.                     ->innerJoin('entity.matter', 'matter')
  668.                     ->addSelect('matter')
  670.                     ->andWhere('entity.reportCard = :reportCard')
  671.                     ->setParameter('reportCard', $schoolReportCard)
  673.                     ->andWhere('entity.average != :average')
  674.                     ->setParameter('average', 999)
  676.                     ->andWhere('entity.as_submatter = :as_submatter')
  677.                     ->setParameter('as_submatter', 0)
  679.                     ->select('SUM(entity.coefficient)')
  680.                     ->getQuery()
  681.                     ->getSingleScalarResult();
  683.                     $schoolReportCard->setTotalAverage($sumAverages);
  684.                     $schoolReportCard->setTotalCoefficient($sumCoefficients);
  685.                     $schoolReportCard->setReportCardAverage(0);
  686.                     
  687.                     if ($sumCoefficients > 0) {
  688.                         $schoolReportCard->setReportCardAverage($sumAverages / $sumCoefficients);
  689.                     }
  690.                 }
  691.             }
  692.         }
  694.         try {
  695.             $entityManager->flush();
  696.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  697.         } catch (\Throwable $th) {
  698.             $this->addFlash('warning', $th->getMessage());
  699.         }
  700.         
  701.         $this->addFlash('warning', "Traitement non effectué");
  702.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  703.     }
  705.     /**
  706.      * @Route("/{id}/compute-min-max-average", name="report_card_compute_min_max_average", methods={"GET"})
  707.     */
  708.     public function computeMinMaxAverage(ReportCard $entity, SchoolReportCardRepository $schoolReportCardRepository): Response
  709.     {
  710.         $entityManager = $this->getDoctrine()->getManager();
  711.         //min max moyenne de la classe
  712.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  713.             $minAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  714.             ->andWhere('entity.reportCard = :reportCard')
  715.             ->setParameter('reportCard', $entity)
  717.             ->andWhere('entity.is_unclassified = :is_unclassified')
  718.             ->setParameter('is_unclassified', 0)
  720.             ->andWhere('entity.classroom = :classroom')
  721.             ->setParameter('classroom', $schoolReportCard->getClassroom())
  722.             
  723.             ->select('MIN(entity.report_card_average)')
  724.             ->getQuery()
  725.             ->getSingleScalarResult();
  727.             $schoolReportCard->setSmallestAverage($minAverage);
  729.             $maxAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  730.             ->andWhere('entity.reportCard = :reportCard')
  731.             ->setParameter('reportCard', $entity)
  733.             ->andWhere('entity.is_unclassified = :is_unclassified')
  734.             ->setParameter('is_unclassified', 0)
  736.             ->andWhere('entity.classroom = :classroom')
  737.             ->setParameter('classroom', $schoolReportCard->getClassroom())
  738.             
  739.             ->select('MAX(entity.report_card_average)')
  740.             ->getQuery()
  741.             ->getSingleScalarResult();
  743.             $schoolReportCard->setSstrongestAverage($maxAverage);
  745.             $classAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  746.             ->andWhere('entity.reportCard = :reportCard')
  747.             ->setParameter('reportCard', $entity)
  749.             ->andWhere('entity.is_unclassified = :is_unclassified')
  750.             ->setParameter('is_unclassified', 0)
  752.             ->andWhere('entity.classroom = :classroom')
  753.             ->setParameter('classroom', $schoolReportCard->getClassroom())
  754.             
  755.             ->select('AVG(entity.report_card_average)')
  756.             ->getQuery()
  757.             ->getSingleScalarResult();
  759.             $schoolReportCard->setClassAverage($classAverage);
  761.             $classAnnualAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  762.             ->andWhere('entity.schoolYear = :schoolYear')
  763.             ->setParameter('schoolYear', $schoolReportCard->getSchoolYear())
  765.             ->andWhere('entity.is_unclassified = :is_unclassified')
  766.             ->setParameter('is_unclassified', 0)
  768.             ->andWhere('entity.classroom = :classroom')
  769.             ->setParameter('classroom', $schoolReportCard->getClassroom())
  770.             
  771.             ->select('AVG(entity.annual_average)')
  772.             ->getQuery()
  773.             ->getSingleScalarResult();
  775.             $schoolReportCard->setClassAnnualAverage($classAnnualAverage);
  776.         }
  778.         try {
  779.             $entityManager->flush();
  780.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  781.         } catch (\Throwable $th) {
  782.             $this->addFlash('warning', $th->getMessage());
  783.         }
  784.         
  785.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  786.     }
  788.     /**
  789.      * @Route("/{id}/compute-rank", name="report_card_compute_rank", methods={"GET"})
  790.     */
  791.     public function computeRank(ReportCard $entity, SchoolReportCardRepository $schoolReportCardRepository, SchoolAverageReportCardRepository $schoolAverageReportCardRepository): Response
  792.     {
  793.         $entityManager = $this->getDoctrine()->getManager();
  794.         $index = 1;
  795.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  796.             // rang de la periode
  797.             foreach ($schoolReportCard->getReportCard()->getLevel()->getSchoolMatters() as $key => $schoolMatter) {
  798.                 $schoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  799.                 ->innerJoin('entity.reportCard', 'schoolReportCard')
  800.                 ->addSelect('schoolReportCard')
  802.                 ->andWhere('schoolReportCard.reportCard = :reportCard')
  803.                 ->setParameter('reportCard', $entity)
  805.                 ->andWhere('entity.classroom = :classroom')
  806.                 ->setParameter('classroom', $schoolReportCard->getClassroom())
  808.                 ->andWhere('entity.matter = :matter')
  809.                 ->setParameter('matter', $schoolMatter)
  811.                 ->andWhere('entity.average < :maxAverage')
  812.                 ->setParameter('maxAverage', 999)
  814.                 ->orderBy('entity.average', 'DESC')
  815.                 ->getQuery()
  816.                 ->getResult();
  818.                 $countSchoolAverageReportCard = 1;
  819.                 $countExSchoolAverageReportCard = 1;
  820.                 $moyPrecedent = -1;
  821.                 
  822.                 foreach ($schoolAverageReportCards as $key => $schoolAverageReportCard) {
  823.                     if ($schoolAverageReportCard->getAverage() >= 999 || $schoolAverageReportCard->getCoefficient() <= 0 || $schoolAverageReportCard->getNoteOn() <= 0) {
  824.                         $schoolAverageReportCard->setRank('NC');
  825.                     }else {
  826.                         if ($schoolAverageReportCard->getSubMatter() == null) {
  827.                             if ($schoolAverageReportCard->getAverage() == $moyPrecedent) {
  828.                                 if ($countSchoolAverageReportCard == 1) {
  829.                                     if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  830.                                         $schoolAverageReportCard->setRank($countExSchoolAverageReportCard.'ère EX');
  831.                                     }else {
  832.                                         $schoolAverageReportCard->setRank($countExSchoolAverageReportCard.'er EX');
  833.                                     }
  834.                                 }else {
  835.                                     $schoolAverageReportCard->setRank($countExSchoolAverageReportCard.'è EX');
  836.                                 }
  837.                             }else {
  838.                                 if ($countSchoolAverageReportCard == 1) {
  839.                                     if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  840.                                         $schoolAverageReportCard->setRank($countSchoolAverageReportCard.'ère');
  841.                                     }else {
  842.                                         $schoolAverageReportCard->setRank($countSchoolAverageReportCard.'er');
  843.                                     }
  844.                                 }else {
  845.                                     $schoolAverageReportCard->setRank($countSchoolAverageReportCard.'è');
  846.                                 }
  847.                                 $countExSchoolAverageReportCard = $countSchoolAverageReportCard;
  848.                             }
  850.                             $countSchoolAverageReportCard++;
  851.                             $moyPrecedent = $schoolAverageReportCard->getAverage();
  852.                         }
  853.                     }
  854.                 }
  855.             }
  857.             foreach ($schoolReportCard->getClassroom()->getLevel()->getSchoolSubMatters() as $key => $schoolSubMatter) {
  858.                 $schoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  859.                 ->innerJoin('entity.reportCard', 'schoolReportCard')
  860.                 ->addSelect('schoolReportCard')
  862.                 ->andWhere('schoolReportCard.reportCard = :reportCard')
  863.                 ->setParameter('reportCard', $entity)
  865.                 ->andWhere('entity.classroom = :classroom')
  866.                 ->setParameter('classroom', $schoolReportCard->getClassroom())
  868.                 ->andWhere('entity.subMatter = :subMatter')
  869.                 ->setParameter('subMatter', $schoolSubMatter)
  871.                 ->andWhere('entity.average < :maxAverage')
  872.                 ->setParameter('maxAverage', 999)
  874.                 ->orderBy('entity.average', 'DESC')
  875.                 ->getQuery()
  876.                 ->getResult();
  877.                 
  878.                 $countSubSchoolAverageReportCard = 1;
  879.                 $countExSubSchoolAverageReportCard = 1;
  880.                 $moySubPrecedent = -1;
  881.                 foreach ($schoolAverageReportCards as $key => $schoolAverageReportCard) {
  882.                     if ($schoolAverageReportCard->getAverage() >= 999 || $schoolAverageReportCard->getCoefficient() <= 0 || $schoolAverageReportCard->getNoteOn() <= 0) {
  883.                         $schoolAverageReportCard->setRank('NC');
  884.                     }else {
  885.                         if ($schoolAverageReportCard->getAverage() == $moySubPrecedent) {
  886.                             if ($countSubSchoolAverageReportCard == 1) {
  887.                                 if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  888.                                     $schoolAverageReportCard->setRank($countExSubSchoolAverageReportCard.'ère EX');
  889.                                 }else {
  890.                                     $schoolAverageReportCard->setRank($countExSubSchoolAverageReportCard.'er EX');
  891.                                 }
  892.                             }else {
  893.                                 $schoolAverageReportCard->setRank($countExSubSchoolAverageReportCard.'è EX');
  894.                             }
  895.                         }else {
  896.                             if ($countSubSchoolAverageReportCard == 1) {
  897.                                 if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  898.                                     $schoolAverageReportCard->setRank($countSubSchoolAverageReportCard.'ère');
  899.                                 }else {
  900.                                     $schoolAverageReportCard->setRank($countSubSchoolAverageReportCard.'er');
  901.                                 }
  902.                             }else {
  903.                                 $schoolAverageReportCard->setRank($countSubSchoolAverageReportCard.'è');
  904.                             }
  905.                             $countExSubSchoolAverageReportCard = $countSubSchoolAverageReportCard;
  906.                         }
  908.                         $countSubSchoolAverageReportCard++;
  909.                         $moySubPrecedent = $schoolAverageReportCard->getAverage();
  910.                     }
  911.                 }
  912.             }
  914.             $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  915.             ->andWhere('entity.reportCard = :reportCard')
  916.             ->setParameter('reportCard', $entity)
  918.             ->andWhere('entity.is_unclassified = :is_unclassified')
  919.             ->setParameter('is_unclassified', 0)
  921.             ->andWhere('entity.classroom = :classroom')
  922.             ->setParameter('classroom', $schoolReportCard->getClassroom())
  924.             ->orderBy('entity.report_card_average', 'DESC')
  925.             ->getQuery()
  926.             ->getResult();
  928.             $count = 1;
  929.             $countEx = 1;
  930.             $moyPre = -1;
  931.             foreach ($schoolReportCards as $key => $schoolReportCard) {
  932.                 if ($schoolReportCard->isUnclassified()) {
  933.                     $schoolReportCard->setRank('NC');
  934.                     $schoolReportCard->setIsUnclassified(true);
  935.                 }else{
  936.                     if ($schoolReportCard->getReportCardAverage() == $moyPre) {
  937.                         if ($count == 1) {
  938.                             if ($schoolReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  939.                                 $schoolReportCard->setRank($countEx.'ère EX');
  940.                             }else {
  941.                                 $schoolReportCard->setRank($countEx.'er EX');
  942.                             }
  943.                         }else {
  944.                             $schoolReportCard->setRank($countEx.'è EX');
  945.                         }
  946.                     }else {
  947.                         if ($count == 1) {
  948.                             if ($schoolReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  949.                                 $schoolReportCard->setRank($count.'ère');
  950.                             }else {
  951.                                 $schoolReportCard->setRank($count.'er');
  952.                             }
  953.                         }else {
  954.                             $schoolReportCard->setRank($count.'è');
  955.                         }
  956.                         $countEx = $count;
  957.                     }
  959.                     $count++;
  960.                     $moyPre = $schoolReportCard->getReportCardAverage();
  961.                 }
  962.             }
  964.             $index++;
  965.         }
  967.         try {
  968.             $entityManager->flush();
  969.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  970.         } catch (\Throwable $th) {
  971.             $this->addFlash('warning', $th->getMessage());
  972.         }
  973.         
  974.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  975.     }
  977.     /**
  978.      * @Route("/{id}/print", name="report_card_print", methods={"GET"})
  979.     */
  980.     public function printReportCards(Request $request, Pdf $knpSnappyPdf, ReportCard $reportCard, SchoolMatterTypeRepository $schoolMatterTypeRepository, SchoolReportCardRepository $schoolReportCardRepository, SettingClassroomRepository $classroomRepository)
  981.     {
  982.         /**@var User $user */
  983.         $user = $this->getUser();
  984.         $schoolYear = $user->getSchoolYear();
  986.         $setting = $reportCard->getEstablishment();
  987.         $template = 'school/print/primaireRepordCards.html.twig';
  988.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  989.             $template = 'school/print/secondaireRepordCards.html.twig';
  990.         }
  992.         $classroomId = $request->query->get('classroom_id');
  993.         $classroom = $classroomId ? $classroomRepository->find($classroomId) : null;
  994.         $schoolReportCards = $schoolReportCardRepository->findByReportCardFiltered($reportCard, $classroom);
  996.         $html = $this->renderView($template, [
  997.             'report_card' => $reportCard,
  998.             'school_report_cards' => $schoolReportCards,
  999.             'school_year' => $schoolYear,
  1000.             'school_matter_types' => $schoolMatterTypeRepository->findBy(['establishment' => $setting], ['order_num' => 'ASC']),
  1001.             'setting' => $setting,
  1002.         ]);
  1004.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1005.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1006.         $options = [
  1007.             'orientation' => 'Portrait'
  1008.             //'header-html' => $header
  1009.             //'footer-html' => $footer
  1010.         ];
  1012.         $file_name = 'BULLETINS_'.$reportCard->getCode().".pdf";
  1014.         try {
  1015.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1016.         } catch (\Throwable $th) {
  1017.             $this->addFlash('info', "Effectué");
  1018.         }
  1020.         return $this->redirectToRoute('preview', [
  1021.             'file' => $file_name,
  1022.             'dir' => 'report-cards',
  1023.         ]);
  1024.     }
  1026.     /**
  1027.      * @Route("/{id}/compute-annual-matter-average", name="report_card_compute_annual_matter_average", methods={"GET"})
  1028.     */
  1029.     public function computeAnnualMatterAverage(ReportCard $reportCard, SchoolAverageReportCardRepository $schoolAverageReportCardRepository, SchoolReportCardRepository $schoolReportCardRepository, SchoolMatterRepository $schoolMatterRepository): Response
  1030.     {
  1031.         $entityManager = $this->getDoctrine()->getManager();
  1032.         // Pour les matières
  1033.         $donnees = new ArrayCollection();
  1034.         foreach ($schoolMatterRepository->findBy(['establishment' => $reportCard->getEstablishment()], []) as $key => $schoolMatter) {
  1035.             if (!$schoolMatter->getIsTestMatter()) {
  1036.                 foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1037.                     foreach ($reportCard->getSchoolReportCards() as $key => $schoolReportCard) {
  1038.                         $subSchoolAverageReportCard = $schoolAverageReportCardRepository->findOneBy(['studentRegistration' => $schoolReportCard->getStudentRegistration(), 'reportCard' => $schoolReportCard, 'subMatter' => $schoolSubMatter], []);
  1039.                         $xAverage = 0;
  1040.                         $coefficient = 0;
  1041.                         $xschoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  1042.                         ->innerJoin('entity.reportCard', 'reportCard')
  1043.                         ->addSelect('reportCard')
  1045.                         ->andWhere('entity.studentRegistration = :studentRegistration')
  1046.                         ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  1048.                         ->andWhere('entity.subMatter = :subMatter')
  1049.                         ->setParameter('subMatter', $schoolSubMatter)
  1051.                         ->andWhere('entity.average < :average')
  1052.                         ->setParameter('average', 999)
  1054.                         ->getQuery()
  1055.                         ->getResult();
  1057.                         foreach ($xschoolAverageReportCards as $key => $xschoolAverageReportCard) {
  1058.                             $xAverage += ($xschoolAverageReportCard->getAverage() * $xschoolAverageReportCard->getReportCard()->getReportCard()->getCoefficient());
  1059.                             $coefficient += $xschoolAverageReportCard->getReportCard()->getReportCard()->getCoefficient();
  1060.                         }
  1062.                         if (null != $subSchoolAverageReportCard && $coefficient > 0) {
  1063.                             $subSchoolAverageReportCard->setAnnualAverage($xAverage / $coefficient);
  1064.                         }
  1065.                     }
  1066.                 }
  1068.                 foreach ($reportCard->getSchoolReportCards() as $key => $schoolReportCard) {
  1069.                     $schoolAverageReportCard = $schoolAverageReportCardRepository->findOneBy(['studentRegistration' => $schoolReportCard->getStudentRegistration(), 'reportCard' => $schoolReportCard, 'matter' => $schoolMatter, 'subMatter' => null], []);
  1070.                     $xAverage = 0;
  1071.                     $coefficient = 0;
  1072.                     $xschoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  1073.                     ->innerJoin('entity.reportCard', 'reportCard')
  1074.                     ->addSelect('reportCard')
  1076.                     ->andWhere('entity.studentRegistration = :studentRegistration')
  1077.                     ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  1079.                     ->andWhere('entity.matter = :matter')
  1080.                     ->setParameter('matter', $schoolMatter)
  1082.                     ->andWhere('entity.average < :average')
  1083.                     ->setParameter('average', 999)
  1085.                     ->getQuery()
  1086.                     ->getResult();
  1088.                     foreach ($xschoolAverageReportCards as $key => $xschoolAverageReportCard) {
  1089.                         if ($xschoolAverageReportCard->getSubMatter() == null) {
  1090.                             $xAverage += ($xschoolAverageReportCard->getAverage() * $xschoolAverageReportCard->getReportCard()->getReportCard()->getCoefficient());
  1091.                             $coefficient += $xschoolAverageReportCard->getReportCard()->getReportCard()->getCoefficient();
  1092.                         }
  1093.                     }
  1095.                     if (null != $schoolAverageReportCard && $coefficient > 0) {
  1096.                         $schoolAverageReportCard->setAnnualAverage($xAverage / $coefficient);
  1097.                     }
  1098.                 }
  1100.                 try {
  1101.                     $entityManager->flush();
  1102.                 } catch (\Throwable $th) {
  1103.                     $this->addFlash('warning', $th->getMessage());
  1104.                 }
  1105.             }
  1107.             
  1108.         }
  1110.         try {
  1111.             $entityManager->flush();
  1112.             return $this->json(['code' => 200, 'message' => "Moyenne annuelle Traitement effectué :)"], 200);
  1113.         } catch (\Throwable $th) {
  1114.             $this->addFlash('warning', $th->getMessage());
  1115.         }
  1116.         
  1117.         $this->addFlash('warning', "Traitement non effectué");
  1118.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  1119.     }
  1121.     /**
  1122.      * @Route("/{id}/compute-annual-report-card-average", name="report_card_compute_annual_report_card_average", methods={"GET"})
  1123.     */
  1124.     public function computeAnnualReportCardAverage(ReportCard $reportCard, SchoolReportCardRepository $schoolReportCardRepository): Response
  1125.     {
  1126.         $entityManager = $this->getDoctrine()->getManager();
  1127.         foreach ($reportCard->getSchoolReportCards() as $key => $schoolReportCard) {
  1128.             $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  1129.             ->andWhere('entity.studentRegistration = :studentRegistration')
  1130.             ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  1131.             ->getQuery()
  1132.             ->getResult();
  1134.             foreach ($schoolReportCards as $key => $schoolReportCard) {
  1135.                 $xAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  1136.                 ->andWhere('entity.studentRegistration = :studentRegistration')
  1137.                 ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  1139.                 ->andWhere('entity.report_card_average > :report_card_average')
  1140.                 ->setParameter('report_card_average', 0)
  1142.                 ->select('SUM(entity.report_card_average * entity.coefficient)')
  1143.                 ->getQuery()
  1144.                 ->getSingleScalarResult();
  1146.                 $coefficient = $schoolReportCardRepository->createQueryBuilder('entity')
  1147.                 ->andWhere('entity.studentRegistration = :studentRegistration')
  1148.                 ->setParameter('studentRegistration', $schoolReportCard->getStudentRegistration())
  1150.                 ->andWhere('entity.report_card_average > :report_card_average')
  1151.                 ->setParameter('report_card_average', 0)
  1153.                 ->select('SUM(entity.coefficient)')
  1154.                 ->getQuery()
  1155.                 ->getSingleScalarResult();
  1157.                 if ($coefficient > 0) {
  1158.                     $schoolReportCard->setAnnualAverage($xAverage / $coefficient );
  1159.                 }
  1160.                 
  1161.             }
  1163.         }
  1165.         try {
  1166.             $entityManager->flush();
  1167.             return $this->json(['code' => 200, 'message' => "Moyenne annuel Traitement effectué :)"], 200);
  1168.         } catch (\Throwable $th) {
  1169.             $this->addFlash('warning', $th->getMessage());
  1170.         }
  1171.         
  1172.         $this->addFlash('warning', "Traitement non effectué");
  1173.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  1174.     }
  1176.     /**
  1177.      * @Route("/{id}/compute-annual-rank", name="report_card_compute_annual_rank", methods={"GET"})
  1178.     */
  1179.     public function computeAnnualRank(ReportCard $entity, SchoolReportCardRepository $schoolReportCardRepository, SchoolAverageReportCardRepository $schoolAverageReportCardRepository): Response
  1180.     {
  1181.         $entityManager = $this->getDoctrine()->getManager();
  1182.         $index = 1;
  1183.         $donnees = new ArrayCollection();
  1185.         $index = 1;
  1186.         foreach ($entity->getSchoolReportCards() as $key => $schoolReportCard) {
  1187.             // rang de la periode
  1188.             foreach ($schoolReportCard->getReportCard()->getLevel()->getSchoolMatters() as $key => $schoolMatter) {
  1189.                 $schoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  1190.                 ->innerJoin('entity.reportCard', 'schoolReportCard')
  1191.                 ->addSelect('schoolReportCard')
  1193.                 ->andWhere('schoolReportCard.reportCard = :reportCard')
  1194.                 ->setParameter('reportCard', $entity)
  1196.                 ->andWhere('entity.classroom = :classroom')
  1197.                 ->setParameter('classroom', $schoolReportCard->getClassroom())
  1199.                 ->andWhere('entity.matter = :matter')
  1200.                 ->setParameter('matter', $schoolMatter)
  1202.                 ->orderBy('entity.annual_average', 'DESC')
  1203.                 ->getQuery()
  1204.                 ->getResult();
  1206.                 $countSchoolAverageReportCard = 1;
  1207.                 $countExSchoolAverageReportCard = 1;
  1208.                 $moyPrecedent = -1;
  1209.                 
  1210.                 foreach ($schoolAverageReportCards as $key => $schoolAverageReportCard) {
  1211.                     if ($schoolAverageReportCard->getAnnualAverage() > 20) {
  1212.                         $schoolAverageReportCard->setAnnualRank('NC');
  1213.                     }else {
  1214.                         if ($schoolAverageReportCard->getSubMatter() == null) {
  1215.                             if ($schoolAverageReportCard->getAnnualAverage() == $moyPrecedent) {
  1216.                                 if ($countSchoolAverageReportCard == 1) {
  1217.                                     if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1218.                                         $schoolAverageReportCard->setAnnualRank($countExSchoolAverageReportCard.'ère EX');
  1219.                                     }else {
  1220.                                         $schoolAverageReportCard->setAnnualRank($countExSchoolAverageReportCard.'er EX');
  1221.                                     }
  1222.                                 }else {
  1223.                                     $schoolAverageReportCard->setAnnualRank($countExSchoolAverageReportCard.'è EX');
  1224.                                 }
  1225.                             }else {
  1226.                                 if ($countSchoolAverageReportCard == 1) {
  1227.                                     if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1228.                                         $schoolAverageReportCard->setAnnualRank($countSchoolAverageReportCard.'ère');
  1229.                                     }else {
  1230.                                         $schoolAverageReportCard->setAnnualRank($countSchoolAverageReportCard.'er');
  1231.                                     }
  1232.                                 }else {
  1233.                                     $schoolAverageReportCard->setAnnualRank($countSchoolAverageReportCard.'è');
  1234.                                 }
  1235.                                 $countExSchoolAverageReportCard = $countSchoolAverageReportCard;
  1236.                             }
  1238.                             $countSchoolAverageReportCard++;
  1239.                             $moyPrecedent = $schoolAverageReportCard->getAnnualAverage();
  1240.                         }
  1241.                     }
  1242.                 }
  1243.             }
  1245.             foreach ($schoolReportCard->getClassroom()->getLevel()->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1246.                 $schoolAverageReportCards = $schoolAverageReportCardRepository->createQueryBuilder('entity')
  1247.                 ->innerJoin('entity.reportCard', 'schoolReportCard')
  1248.                 ->addSelect('schoolReportCard')
  1250.                 ->andWhere('schoolReportCard.reportCard = :reportCard')
  1251.                 ->setParameter('reportCard', $entity)
  1253.                 ->andWhere('entity.classroom = :classroom')
  1254.                 ->setParameter('classroom', $schoolReportCard->getClassroom())
  1256.                 ->andWhere('entity.subMatter = :subMatter')
  1257.                 ->setParameter('subMatter', $schoolSubMatter)
  1259.                 ->orderBy('entity.annual_average', 'DESC')
  1260.                 ->getQuery()
  1261.                 ->getResult();
  1262.                 
  1263.                 $countSubSchoolAverageReportCard = 1;
  1264.                 $countExSubSchoolAverageReportCard = 1;
  1265.                 $moySubPrecedent = -1;
  1266.                 foreach ($schoolAverageReportCards as $key => $schoolAverageReportCard) {
  1267.                     if ($schoolAverageReportCard->getAverage() >= 999 || $schoolAverageReportCard->getCoefficient() <= 0 || $schoolAverageReportCard->getNoteOn() <= 0) {
  1268.                         $schoolAverageReportCard->setAnnualRank('NC');
  1269.                     }else {
  1270.                         if ($schoolAverageReportCard->getAverage() == $moySubPrecedent) {
  1271.                             if ($countSubSchoolAverageReportCard == 1) {
  1272.                                 if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1273.                                     $schoolAverageReportCard->setAnnualRank($countExSubSchoolAverageReportCard.'ère EX');
  1274.                                 }else {
  1275.                                     $schoolAverageReportCard->setAnnualRank($countExSubSchoolAverageReportCard.'er EX');
  1276.                                 }
  1277.                             }else {
  1278.                                 $schoolAverageReportCard->setAnnualRank($countExSubSchoolAverageReportCard.'è EX');
  1279.                             }
  1280.                         }else {
  1281.                             if ($countSubSchoolAverageReportCard == 1) {
  1282.                                 if ($schoolAverageReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1283.                                     $schoolAverageReportCard->setAnnualRank($countSubSchoolAverageReportCard.'ère');
  1284.                                 }else {
  1285.                                     $schoolAverageReportCard->setAnnualRank($countSubSchoolAverageReportCard.'er');
  1286.                                 }
  1287.                             }else {
  1288.                                 $schoolAverageReportCard->setAnnualRank($countSubSchoolAverageReportCard.'è');
  1289.                             }
  1290.                             $countExSubSchoolAverageReportCard = $countSubSchoolAverageReportCard;
  1291.                         }
  1293.                         $countSubSchoolAverageReportCard++;
  1294.                         $moySubPrecedent = $schoolAverageReportCard->getAverage();
  1295.                     }
  1296.                 }
  1297.             }
  1298.         }
  1300.         foreach ($entity->getLevel()->getSettingClassrooms() as $key => $classroom) {
  1301.             $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  1302.             ->andWhere('entity.reportCard = :reportCard')
  1303.             ->setParameter('reportCard', $entity)
  1305.             ->andWhere('entity.classroom = :classroom')
  1306.             ->setParameter('classroom', $classroom)
  1308.             ->orderBy('entity.annual_average', 'DESC')
  1309.             ->getQuery()
  1310.             ->getResult();
  1312.             $count = 1;
  1313.             $countEx = 1;
  1314.             $moySubPre = -1;
  1315.             foreach ($schoolReportCards as $key => $schoolReportCard) {
  1316.                 if ($schoolReportCard->getAnnualAverage() == $moySubPre) {
  1317.                     if ($count == 1) {
  1318.                         if ($schoolReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1319.                             $schoolReportCard->setAnnualRank($countEx.'ère EX');
  1320.                         }else {
  1321.                             $schoolReportCard->setAnnualRank($countEx.'er EX');
  1322.                         }
  1323.                     }else {
  1324.                         $schoolReportCard->setAnnualRank($countEx.'è EX');
  1325.                     }
  1326.                 }else {
  1327.                     if ($count == 1) {
  1328.                         if ($schoolReportCard->getStudentRegistration()->getStudent()->getGender() == 'FEMININ') {
  1329.                             $schoolReportCard->setAnnualRank($count.'ère');
  1330.                         }else {
  1331.                             $schoolReportCard->setAnnualRank($count.'er');
  1332.                         }
  1333.                     }else {
  1334.                         $schoolReportCard->setAnnualRank($count.'è');
  1335.                     }
  1336.                     $countEx = $count;
  1337.                 }
  1339.                 $count++;
  1340.                 $moySubPre = $schoolReportCard->getAnnualAverage();
  1341.             }
  1343.             $index++;
  1344.         }
  1346.         try {
  1347.             $entityManager->flush();
  1348.             return $this->json(['code' => 200, 'message' => "Ran annuel Traitement effectué :)"], 200);
  1349.         } catch (\Throwable $th) {
  1350.             $this->addFlash('warning', $th->getMessage());
  1351.         }
  1352.         
  1353.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  1354.     }
  1356.     /**
  1357.      * @Route("/{id}/maternelle-print", name="report_card_maternelle_print", methods={"GET"})
  1358.     */
  1359.     public function printMaternelleReportCards(Request $request, Pdf $knpSnappyPdf, ReportCard $reportCard, SchoolMatterTypeRepository $schoolMatterTypeRepository, SchoolReportCardRepository $schoolReportCardRepository, SettingClassroomRepository $classroomRepository)
  1360.     {
  1361.         /**@var User $user */
  1362.         $user = $this->getUser();
  1363.         $schoolYear = $user->getSchoolYear();
  1365.         $setting = $reportCard->getEstablishment();
  1366.         $template = 'school/print/maternelleRepordCards.html.twig';
  1368.         $classroomId = $request->query->get('classroom_id');
  1369.         $classroom = $classroomId ? $classroomRepository->find($classroomId) : null;
  1370.         $schoolReportCards = $schoolReportCardRepository->findByReportCardFiltered($reportCard, $classroom);
  1372.         $html = $this->renderView($template, [
  1373.             'report_card' => $reportCard,
  1374.             'school_report_cards' => $schoolReportCards,
  1375.             'school_year' => $schoolYear,
  1376.             'school_matter_types' => $schoolMatterTypeRepository->findBy(['establishment' => $setting], ['order_num' => 'ASC']),
  1377.             'setting' => $setting,
  1378.         ]);
  1380.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1381.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1382.         $options = [
  1383.             'orientation' => 'Portrait'
  1384.             //'header-html' => $header
  1385.             //'footer-html' => $footer
  1386.         ];
  1388.         $file_name = 'BULLETINS_MATERNELLE_'.$reportCard->getCode().".pdf";
  1390.         try {
  1391.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1392.         } catch (\Throwable $th) {
  1393.             $this->addFlash('info', "Effectué");
  1394.         }
  1396.         return $this->redirectToRoute('preview', [
  1397.             'file' => $file_name,
  1398.             'dir' => 'report-cards',
  1399.         ]);
  1400.     }
  1402.     /**
  1403.      * @Route("/{id}/last-maternelle-print", name="report_card_last_maternelle_print", methods={"GET"})
  1404.     */
  1405.     public function printLastMaternelleReportCards(Request $request, Pdf $knpSnappyPdf, ReportCard $reportCard, SchoolMatterTypeRepository $schoolMatterTypeRepository, SchoolReportCardRepository $schoolReportCardRepository, SettingClassroomRepository $classroomRepository)
  1406.     {
  1407.         /**@var User $user */
  1408.         $user = $this->getUser();
  1409.         $schoolYear = $user->getSchoolYear();
  1411.         $setting = $reportCard->getEstablishment();
  1412.         $template = 'school/print/maternelleLastRepordCards.html.twig';
  1414.         $classroomId = $request->query->get('classroom_id');
  1415.         $classroom = $classroomId ? $classroomRepository->find($classroomId) : null;
  1416.         $schoolReportCards = $schoolReportCardRepository->findByReportCardFiltered($reportCard, $classroom);
  1418.         $html = $this->renderView($template, [
  1419.             'report_card' => $reportCard,
  1420.             'school_report_cards' => $schoolReportCards,
  1421.             'school_year' => $schoolYear,
  1422.             'school_matter_types' => $schoolMatterTypeRepository->findBy(['establishment' => $setting], ['order_num' => 'ASC']),
  1423.             'setting' => $setting,
  1424.         ]);
  1426.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1427.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1428.         $options = [
  1429.             'orientation' => 'Portrait'
  1430.             //'header-html' => $header
  1431.             //'footer-html' => $footer
  1432.         ];
  1434.         $file_name = 'BULLETINS_ANNUELS_MATERNELLE_'.$reportCard->getCode().".pdf";
  1436.         try {
  1437.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1438.         } catch (\Throwable $th) {
  1439.             $this->addFlash('info', "Effectué");
  1440.         }
  1442.         return $this->redirectToRoute('preview', [
  1443.             'file' => $file_name,
  1444.             'dir' => 'report-cards',
  1445.         ]);
  1446.     }
  1448.     /**
  1449.      * @Route("/{id}/last-print", name="report_card_last_print", methods={"GET"})
  1450.     */
  1451.     public function printLastReportCards(Request $request, Pdf $knpSnappyPdf, ReportCard $reportCard, SchoolMatterTypeRepository $schoolMatterTypeRepository, SchoolReportCardRepository $schoolReportCardRepository, SettingClassroomRepository $classroomRepository)
  1452.     {
  1453.         /**@var User $user */
  1454.         $user = $this->getUser();
  1455.         $schoolYear = $user->getSchoolYear();
  1457.         $setting = $reportCard->getEstablishment();
  1458.         $template = 'school/print/primaireLastRepordCards.html.twig';
  1459.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1460.             $template = 'school/print/secondaireLastRepordCards.html.twig';
  1461.         }
  1463.         $classroomId = $request->query->get('classroom_id');
  1464.         $classroom = $classroomId ? $classroomRepository->find($classroomId) : null;
  1465.         $schoolReportCards = $schoolReportCardRepository->findByReportCardFiltered($reportCard, $classroom);
  1467.         $html = $this->renderView($template, [
  1468.             'report_card' => $reportCard,
  1469.             'school_report_cards' => $schoolReportCards,
  1470.             'schoolReportCardRepository' => $schoolReportCardRepository,
  1471.             'school_year' => $schoolYear,
  1472.             'school_matter_types' => $schoolMatterTypeRepository->findBy(['establishment' => $setting], ['order_num' => 'ASC']),
  1473.             'setting' => $setting,
  1474.         ]);
  1476.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1477.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1478.         $options = [
  1479.             'orientation' => 'Portrait'
  1480.             //'header-html' => $header
  1481.             //'footer-html' => $footer
  1482.         ];
  1484.         $file_name = 'BULLETINS_ANNUELS_'.$reportCard->getCode().".pdf";
  1486.         try {
  1487.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1488.         } catch (\Throwable $th) {
  1489.             $this->addFlash('info', "Effectué");
  1490.         }
  1492.         return $this->redirectToRoute('preview', [
  1493.             'file' => $file_name,
  1494.             'dir' => 'report-cards',
  1495.         ]);
  1496.     }
  1498.     /**
  1499.      * @Route("/{id}/blank-note-card-print", name="report_card_blank_note_card_print", methods={"GET"})
  1500.     */
  1501.     public function printBlankNoteCard(Pdf $knpSnappyPdf, ReportCard $reportCard)
  1502.     {
  1503.         /**@var User $user */
  1504.         $user = $this->getUser();
  1505.         $schoolYear = $user->getSchoolYear();
  1507.         $setting = $reportCard->getEstablishment();
  1508.         $template = 'school/print/blankNoteCard.html.twig';
  1509.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1510.             $template = 'school/print/blankNoteCard.html.twig';
  1511.         }
  1512.         
  1513.         $html = $this->renderView($template, [
  1514.             'report_card' => $reportCard,
  1515.             'school_year' => $schoolYear,
  1516.             'setting' => $setting,
  1517.         ]);
  1519.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1520.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1521.         $options = [
  1522.             'orientation' => 'Landscape',
  1523.             'header-html' => $header,
  1524.             'footer-html' => $footer
  1525.         ];
  1527.         $file_name = 'FICHE_DE_NOTES_VIDE_'.$reportCard->getCode().".pdf";
  1529.         try {
  1530.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1531.         } catch (\Throwable $th) {
  1532.             $this->addFlash('info', "Effectué");
  1533.         }
  1535.         return $this->redirectToRoute('preview', [
  1536.             'file' => $file_name,
  1537.             'dir' => 'report-cards',
  1538.         ]);
  1539.     }
  1541.     /**
  1542.      * @Route("/{id}/note-card-print", name="report_card_note_card_print", methods={"GET"})
  1543.     */
  1544.     public function printNoteCard(Pdf $knpSnappyPdf, ReportCard $reportCard)
  1545.     {
  1546.         /**@var User $user */
  1547.         $user = $this->getUser();
  1548.         $schoolYear = $user->getSchoolYear();
  1550.         $setting = $reportCard->getEstablishment();
  1551.         $template = 'school/print/noteCard.html.twig';
  1552.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1553.             $template = 'school/print/noteCard.html.twig';
  1554.         }
  1555.         
  1556.         $html = $this->renderView($template, [
  1557.             'report_card' => $reportCard,
  1558.             'school_year' => $schoolYear,
  1559.             'setting' => $setting,
  1560.         ]);
  1562.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1563.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1564.         $options = [
  1565.             'orientation' => 'Landscape',
  1566.             'header-html' => $header,
  1567.             'footer-html' => $footer
  1568.         ];
  1570.         $file_name = 'FICHE_DE_NOTES_'.$reportCard->getCode().".pdf";
  1572.         try {
  1573.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1574.         } catch (\Throwable $th) {
  1575.             $this->addFlash('info', "Effectué");
  1576.         }
  1578.         return $this->redirectToRoute('preview', [
  1579.             'file' => $file_name,
  1580.             'dir' => 'report-cards',
  1581.         ]);
  1582.     }
  1584.     /**
  1585.      * @Route("/{id}/assessment-slip-print", name="report_card_assessment_slip_print", methods={"GET"})
  1586.     */
  1587.     public function printAssessmentSlip(Pdf $knpSnappyPdf, ReportCard $reportCard)
  1588.     {
  1589.         /**@var User $user */
  1590.         $user = $this->getUser();
  1591.         $schoolYear = $user->getSchoolYear();
  1593.         $setting = $reportCard->getEstablishment();
  1594.         $template = 'school/print/assessmentSlip.html.twig';
  1595.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1596.             $template = 'school/print/assessmentSlip.html.twig';
  1597.         }
  1598.         
  1599.         $html = $this->renderView($template, [
  1600.             'report_card' => $reportCard,
  1601.             'school_year' => $schoolYear,
  1602.             'setting' => $setting,
  1603.         ]);
  1605.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1606.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1607.         $options = [
  1608.             'orientation' => 'Landscape',
  1609.             'header-html' => $header,
  1610.             'footer-html' => $footer
  1611.         ];
  1613.         $file_name = 'BORDEREAU_EVALUATION_'.$reportCard->getCode().".pdf";
  1615.         try {
  1616.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1617.         } catch (\Throwable $th) {
  1618.             $this->addFlash('info', "Effectué");
  1619.         }
  1621.         return $this->redirectToRoute('preview', [
  1622.             'file' => $file_name,
  1623.             'dir' => 'report-cards',
  1624.         ]);
  1625.     }
  1627.     /**
  1628.      * @Route("/{id}/compute-level-average", name="report_card_compute_level_average", methods={"GET"})
  1629.     */
  1630.     public function computeLevelAverage(ReportCard $entity, SchoolReportCardRepository $schoolReportCardRepository): Response
  1631.     {
  1632.         $entityManager = $this->getDoctrine()->getManager();
  1633.         $levelAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  1634.         ->andWhere('entity.reportCard = :reportCard')
  1635.         ->setParameter('reportCard', $entity)
  1637.         ->andWhere('entity.is_unclassified = :is_unclassified')
  1638.         ->setParameter('is_unclassified', 0)
  1639.         
  1640.         ->select('AVG(entity.report_card_average)')
  1641.         ->getQuery()
  1642.         ->getSingleScalarResult();
  1644.         $minAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  1645.         ->andWhere('entity.reportCard = :reportCard')
  1646.         ->setParameter('reportCard', $entity)
  1648.         ->andWhere('entity.is_unclassified = :is_unclassified')
  1649.         ->setParameter('is_unclassified', 0)
  1650.         
  1651.         ->select('MIN(entity.report_card_average)')
  1652.         ->getQuery()
  1653.         ->getSingleScalarResult();
  1655.         $maxAverage = $schoolReportCardRepository->createQueryBuilder('entity')
  1656.         ->andWhere('entity.reportCard = :reportCard')
  1657.         ->setParameter('reportCard', $entity)
  1659.         ->andWhere('entity.is_unclassified = :is_unclassified')
  1660.         ->setParameter('is_unclassified', 0)
  1661.         
  1662.         ->select('MAX(entity.report_card_average)')
  1663.         ->getQuery()
  1664.         ->getSingleScalarResult();
  1666.         $entity->setLevelAverage($levelAverage);
  1667.         $entity->setReportCardAverage($levelAverage);
  1668.         $entity->setSmallestAverage($minAverage);
  1669.         $entity->setStrongestAverage($maxAverage);
  1671.         try {
  1672.             $entityManager->flush();
  1673.             return $this->json(['code' => 200, 'message' => "Traitement effectué :)"], 200);
  1674.         } catch (\Throwable $th) {
  1675.             $this->addFlash('warning', $th->getMessage());
  1676.         }
  1677.         
  1678.         return $this->json(['code' => 500, 'message' => "Traitement non effectué"], 200);
  1679.     }
  1681.     /**
  1682.      * @Route("/{id}/annul-assessment-slip-print", name="report_card_annual_assessment_slip_print", methods={"GET"})
  1683.     */
  1684.     public function printAnnualAssessmentSlip(Pdf $knpSnappyPdf, ReportCard $reportCard)
  1685.     {
  1686.         /**@var User $user */
  1687.         $user = $this->getUser();
  1688.         $schoolYear = $user->getSchoolYear();
  1690.         $setting = $reportCard->getEstablishment();
  1691.         $template = 'school/print/annual_assessment_slip.html.twig';
  1692.         if ($setting->getType() != $setting::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1693.             $template = 'school/print/annual_assessment_slip.html.twig';
  1694.         }
  1695.         
  1696.         $html = $this->renderView($template, [
  1697.             'report_card' => $reportCard,
  1698.             'school_year' => $schoolYear,
  1699.             'setting' => $setting,
  1700.         ]);
  1702.         $footer = $this->renderView('print/footer.html.twig', ['setting' => $setting,]);
  1703.         $header = $this->renderView('print/header.html.twig', ['setting' => $setting,]);
  1704.         $options = [
  1705.             'orientation' => 'Landscape',
  1706.             'header-html' => $header,
  1707.             'footer-html' => $footer
  1708.         ];
  1710.         $file_name = "BORDEREAU_EVALUATION_ANNUELLE_.pdf";
  1712.         try {
  1713.             $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/report-cards/' . $file_name, $options, true);
  1714.         } catch (\Throwable $th) {
  1715.             $this->addFlash('info', "Effectué");
  1716.         }
  1718.         return $this->redirectToRoute('preview', [
  1719.             'file' => $file_name,
  1720.             'dir' => 'report-cards',
  1721.         ]);
  1722.     }
  1724.     /**
  1725.      * @Route("/absence", name="report_card_absence", methods={"GET"})
  1726.      */
  1727.     public function absence(Pdf $knpSnappyPdf, Request $request, ReportCardRepository $reportCardRepository, SchoolYearPeriodeRepository $schoolYearPeriodeRepository, SettingClassroomRepository $settingClassroomRepository, EntityManagerInterface $entityManager, SchoolReportCardAbsenceRepository $schoolReportCardAbsenceRepository): Response
  1728.     {
  1729.         /**@var User $user */
  1730.         $user = $this->getUser();
  1731.         $schoolYear = $user->getSchoolYear();
  1732.         $establishment = $user->getEstablishment();
  1734.         $requestedOutput = $request->query->get('output', $request->query->get('action', 'show'));
  1736.         $schoolYearPeriode = $schoolYearPeriodeRepository->findOneBy(['establishment' => $establishment, 'id' => $request->get('schoolYearPeriode')], []);
  1737.         $schoolYearPeriodes = $schoolYearPeriodeRepository->findBy(['establishment' => $establishment, 'schoolYear' => $schoolYear], []);
  1739.         $settingClassrooms = $settingClassroomRepository->findBy(['establishment' => $establishment, 'schoolYear' => $schoolYear], []);
  1740.         $settingClassroomId = $request->get('settingClassroom');
  1741.         $settingClassroom = null;
  1743.         if (null !== $settingClassroomId && '' !== $settingClassroomId && '0' !== (string) $settingClassroomId) {
  1744.             $settingClassroom = $settingClassroomRepository->findOneBy(['establishment' => $establishment, 'id' => $settingClassroomId], []);
  1745.         }
  1747.         $reportCards = [];
  1748.         if (null !== $schoolYearPeriode) {
  1749.             $reportCards = $reportCardRepository->findBy(['establishment' => $establishment, 'schoolYearPeriode' => $schoolYearPeriode], []);
  1750.         }
  1752.         if (null != $schoolYearPeriode) {
  1753.             $selectedClassrooms = null !== $settingClassroom ? [$settingClassroom] : $settingClassrooms;
  1755.             foreach ($selectedClassrooms as $selectedClassroom) {
  1756.                 foreach ($selectedClassroom->getRegistereds($schoolYear) as $key => $studentRegistration) {
  1757.                     if (null == $schoolReportCardAbsenceRepository->findOneBy(['schoolYearPeriode' => $schoolYearPeriode, 'studentRegistration' => $studentRegistration], [])) {
  1758.                         $schoolReportCardAbsence = new SchoolReportCardAbsence();
  1759.                         $schoolReportCardAbsence->setEstablishment($establishment);
  1760.                         $schoolReportCardAbsence->setSchoolYear($schoolYear);
  1761.                         $schoolReportCardAbsence->setSchoolYearPeriode($schoolYearPeriode);
  1762.                         $schoolReportCardAbsence->setStudentRegistration($studentRegistration);
  1763.                         $schoolReportCardAbsence->setClassroom($selectedClassroom);
  1764.                         $schoolReportCardAbsence->setTotalAbsence($schoolReportCardAbsence->getNbHAbsence($schoolYearPeriode->getBeginAt(), $schoolYearPeriode->getEndAt()));
  1765.                         $schoolReportCardAbsence->setUnjustifiedAbsence($schoolReportCardAbsence->getNbHAbsence($schoolYearPeriode->getBeginAt(), $schoolYearPeriode->getEndAt()));
  1766.                         $schoolReportCardAbsence->setJustifiedAbsence(0);
  1768.                         $entityManager->persist($schoolReportCardAbsence);
  1769.                     }
  1770.                 }
  1771.             }
  1772.         }
  1774.         try {
  1775.             $entityManager->flush();
  1776.         } catch (\Throwable $th) {
  1777.             //throw $th;
  1778.         }
  1780.         $schoolReportCardAbsences = [];
  1781.         if (null !== $schoolYearPeriode) {
  1782.             $queryBuilder = $schoolReportCardAbsenceRepository->createQueryBuilder('entity')
  1783.             ->andWhere('entity.schoolYearPeriode = :schoolYearPeriode')
  1784.             ->setParameter('schoolYearPeriode', $schoolYearPeriode)
  1786.             ->innerJoin('entity.studentRegistration', 'studentRegistration')
  1787.             ->addSelect('studentRegistration')
  1789.             ->innerJoin('studentRegistration.student', 'student')
  1790.             ->addSelect('student')
  1792.             ->orderBy('student.last_name', 'asc')
  1793.             ->addOrderBy('student.first_name', 'asc');
  1795.             if (null !== $settingClassroom) {
  1796.                 $queryBuilder
  1797.                 ->andWhere('entity.classroom = :classroom')
  1798.                 ->setParameter('classroom', $settingClassroom);
  1799.             }
  1801.             $schoolReportCardAbsences = $queryBuilder
  1802.             ->getQuery()
  1803.             ->getResult();
  1804.         }
  1806.         if ('excel' === $requestedOutput) {
  1807.             $sortedSchoolReportCardAbsences = $schoolReportCardAbsences;
  1809.             usort($sortedSchoolReportCardAbsences, function (SchoolReportCardAbsence $left, SchoolReportCardAbsence $right) {
  1810.                 $absenceComparison = ($left->getUnjustifiedAbsence() ?? 0) <=> ($right->getUnjustifiedAbsence() ?? 0);
  1811.                 if (0 !== $absenceComparison) {
  1812.                     return $absenceComparison;
  1813.                 }
  1815.                 $classroomComparison = strcmp((string) $left->getClassroom(), (string) $right->getClassroom());
  1816.                 if (0 !== $classroomComparison) {
  1817.                     return $classroomComparison;
  1818.                 }
  1820.                 return strcmp($left->getStudentRegistration()->getName(), $right->getStudentRegistration()->getName());
  1821.             });
  1823.             $spreadsheet = new Spreadsheet();
  1824.             $sheet = $spreadsheet->getActiveSheet();
  1825.             $index = 1;
  1827.             $sheet->setCellValue('A' . $index, 'RANG');
  1828.             $sheet->setCellValue('B' . $index, 'NOM ET PRENOMS');
  1829.             $sheet->setCellValue('C' . $index, 'MATRICULE');
  1830.             $sheet->setCellValue('D' . $index, 'CLASSE');
  1831.             $sheet->setCellValue('E' . $index, 'PERIODE');
  1832.             $sheet->setCellValue('F' . $index, 'TOTAL H. ABSENCE');
  1833.             $sheet->setCellValue('G' . $index, 'TOTAL H. JUSTIFIE');
  1834.             $sheet->setCellValue('H' . $index, 'TOTAL H. NON JUSTIFIE');
  1835.             $index++;
  1837.             foreach ($sortedSchoolReportCardAbsences as $loopIndex => $schoolReportCardAbsence) {
  1838.                 $sheet->setCellValue('A' . $index, $loopIndex + 1);
  1839.                 $sheet->setCellValue('B' . $index, $schoolReportCardAbsence->getStudentRegistration()->getName());
  1840.                 $sheet->setCellValue('C' . $index, $schoolReportCardAbsence->getStudentRegistration()->getStudent()->getRegistrationNumber());
  1841.                 $sheet->setCellValue('D' . $index, (string) $schoolReportCardAbsence->getClassroom());
  1842.                 $sheet->setCellValue('E' . $index, (string) $schoolReportCardAbsence->getSchoolYearPeriode());
  1843.                 $sheet->setCellValue('F' . $index, $schoolReportCardAbsence->getTotalAbsence());
  1844.                 $sheet->setCellValue('G' . $index, $schoolReportCardAbsence->getJustifiedAbsence());
  1845.                 $sheet->setCellValue('H' . $index, $schoolReportCardAbsence->getUnjustifiedAbsence());
  1846.                 $index++;
  1847.             }
  1849.             foreach (range('A', 'H') as $column) {
  1850.                 $sheet->getColumnDimension($column)->setAutoSize(true);
  1851.             }
  1853.             $sheet->setTitle('ABSENCES');
  1854.             $writer = new Xlsx($spreadsheet);
  1855.             $classroomLabel = null !== $settingClassroom ? preg_replace('/[^A-Za-z0-9_-]/', '_', (string) $settingClassroom) : 'TOUTES_CLASSES';
  1856.             $periodeLabel = null !== $schoolYearPeriode ? preg_replace('/[^A-Za-z0-9_-]/', '_', (string) $schoolYearPeriode) : 'SANS_PERIODE';
  1857.             $fileName = 'ABSENCE_BULLETIN_' . $periodeLabel . '_' . $classroomLabel . '.xlsx';
  1858.             $temp_file = sys_get_temp_dir() . DIRECTORY_SEPARATOR . uniqid('absence_bulletin_', true) . '.xlsx';
  1859.             $writer->save($temp_file);
  1861.             $response = new BinaryFileResponse($temp_file);
  1862.             $response->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
  1863.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $fileName);
  1864.             $response->deleteFileAfterSend(true);
  1866.             return $response;
  1867.         }
  1869.         if ('print' === $requestedOutput) {
  1870.             $html = $this->renderView('school/report_card/print/absence.html.twig', [
  1871.                 'school_report_card_absences' => $schoolReportCardAbsences,
  1872.                 'report_cards' => $reportCards,
  1873.                 'school_year_periodes' => $schoolYearPeriodes,
  1874.                 'school_year_periode' => $schoolYearPeriode,
  1876.                 'setting_classrooms' => $settingClassrooms,
  1877.                 'setting_classroom' => $settingClassroom,
  1878.     
  1879.                 'school_year' => $schoolYear,
  1880.                 'setting' => $establishment,
  1881.             ]);
  1882.     
  1883.             $file_name = "ABSENCE_BULLETIN_.pdf";
  1884.     
  1885.             $footer = $this->renderView('print/footer.html.twig', ['setting' => $establishment]);
  1886.             $header = $this->renderView('print/header.html.twig', ['setting' => $establishment]);
  1887.             
  1888.             $options = [
  1889.                 'orientation' => 'Portrait',
  1890.                 'header-html' => $header,
  1891.                 'footer-html' => $footer
  1892.             ];
  1893.             
  1894.             try {
  1895.                 $knpSnappyPdf->generateFromHtml($html, $this->getParameter('app.app_directory').'/downloads/recovery/' . $file_name, $options, true);
  1896.             } catch (\Throwable $th) {
  1897.                 $this->addFlash('info', "Une erreur c'est produite");
  1898.             }
  1899.             
  1900.     
  1901.             return $this->redirectToRoute('preview', [
  1902.                 'file' => $file_name,
  1903.                 'dir' => 'recovery',
  1904.             ]);
  1905.         }
  1907.         return $this->render('school/report_card/absence.html.twig', [
  1908.             'school_report_card_absences' => $schoolReportCardAbsences,
  1909.             'report_cards' => $reportCards,
  1910.             'school_year_periodes' => $schoolYearPeriodes,
  1911.             'school_year_periode' => $schoolYearPeriode,
  1913.             'setting_classrooms' => $settingClassrooms,
  1914.             'setting_classroom' => $settingClassroom,
  1915.             'requested_output' => $requestedOutput,
  1916.         ]);
  1917.     }
  1918. }