src/Entity/RegistrationStudentRegistration.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\RegistrationStudentRegistrationRepository;
  6. use App\Repository\SchoolReportCardRepository;
  7. use DateTimeImmutable;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Symfony\Component\Validator\Constraints as Assert;
  17. /**
  18.  * @ORM\Entity(repositoryClass=RegistrationStudentRegistrationRepository::class)
  19.  * Inscrits
  20.  * @Vich\Uploadable
  21.  */
  22. class RegistrationStudentRegistration
  23. {
  24.     public const STATUS = ['INSCRIT' => 'INSCRIT', 'ABANDONNE' => 'ABANDONNE'];
  25.     public const STATUS_INSCRIT = 'INSCRIT';
  26.     public const STATUS_ABANDONNE = 'ABANDONNE';
  28.     /**
  29.      * @ORM\Id
  30.      * @ORM\GeneratedValue
  31.      * @ORM\Column(type="integer")
  32.      */
  33.     private $id;
  35.     /**
  36.      * @ORM\ManyToOne(targetEntity=Establishment::class, inversedBy="registrationStudentRegistrations")
  37.      * @ORM\JoinColumn(nullable=false)
  38.      */
  39.     private $establishment;
  41.     /**
  42.      * @ORM\ManyToOne(targetEntity=RegistrationStudent::class, inversedBy="registrationStudentRegistrations")
  43.      * @ORM\JoinColumn(nullable=false)
  44.      */
  45.     private $student;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=SchoolYear::class, inversedBy="registrationStudentRegistrations")
  49.      * @ORM\JoinColumn(nullable=false)
  50.      */
  51.     private $schoolYear;
  53.     /**
  54.      * @ORM\ManyToOne(targetEntity=SettingClassroom::class, inversedBy="registrationStudentRegistrations")
  55.      * @ORM\JoinColumn(nullable=false)
  56.      */
  57.     private $classroom;
  59.     /**
  60.      * @ORM\Column(type="boolean")
  61.      */
  62.     private $is_redoubling;
  64.     /**
  65.      * @ORM\Column(type="boolean")
  66.      * est boursier
  67.      */
  68.     private $is_diet;
  70.     /**
  71.      * @ORM\Column(type="boolean")
  72.      * est interne
  73.      */
  74.     private $is_internal;
  76.     /**
  77.      * @ORM\Column(type="boolean")
  78.      * est affecte(e)
  79.     */
  80.     private $is_affected;
  82.     /**
  83.      * @ORM\Column(type="date_immutable")
  84.     */
  85.     private $registered_at;
  87.     /**
  88.      * @ORM\Column(type="datetime_immutable")
  89.     */
  90.     private $created_at;
  92.     /**
  93.      * @ORM\Column(type="datetime_immutable")
  94.      */
  95.     private $updated_at;
  97.     /**
  98.      * @ORM\Column(type="integer")
  99.      */
  100.     private $created_by;
  102.     /**
  103.      * @ORM\Column(type="integer")
  104.      */
  105.     private $updated_by;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationFee::class, mappedBy="studentRegistration")
  109.      */
  110.     private $accountingStudentRegistrationFees;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=SchoolReportCard::class, mappedBy="studentRegistration")
  114.      * @ORM\OrderBy({"id" = "ASC"})
  115.      */
  116.     private $schoolReportCards;
  118.     /**
  119.      * @ORM\OneToMany(targetEntity=SchoolAverageReportCard::class, mappedBy="studentRegistration")
  120.      */
  121.     private $schoolAverageReportCards;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClass::class, mappedBy="studentRegistration")
  125.      */
  126.     private $schoolAssessmentByClasses;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevel::class, mappedBy="studentRegistration")
  130.      */
  131.     private $schoolAssessmentByLevels;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClassByMatter::class, mappedBy="studentRegistration")
  135.      */
  136.     private $schoolAssessmentByClassByMatters;
  138.     /**
  139.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevelByMatter::class, mappedBy="studentRegistration")
  140.      */
  141.     private $schoolAssessmentByLevelByMatters;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationPayment::class, mappedBy="studentRegistration")
  145.      */
  146.     private $accountingStudentRegistrationPayments;
  148.     /**
  149.      * @ORM\Column(type="float", nullable=true)
  150.     */
  151.     private $last_amount_paid;
  153.     /**
  154.      * @ORM\Column(type="integer", nullable=true)
  155.     */
  156.     private $last_payment_id;
  158.     /**
  159.      * @ORM\Column(type="datetime_immutable", nullable=true)
  160.     */
  161.     private $last_payment_at;
  163.     /**
  164.      * @ORM\Column(type="string", length=255, nullable=true)
  165.      */
  166.     private $image;
  168.     /**
  169.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  170.      * 
  171.      * @Vich\UploadableField(mapping="student", fileNameProperty="image")
  172.      * 
  173.      * @var File|null
  174.      * @Assert\File(
  175.      * maxSize = "25M",
  176.      * mimeTypes = {"image/png", "image/jpg", "image/jpeg"},
  177.      * mimeTypesMessage = "Veuillez télécharger une image valide (png, jpg, jpeg)",
  178.      * maxSizeMessage = "Le fichier est trop volumineux ({{size}} {{suffix}}). La taille maximale autorisée est {{limit}} {{suffix}}"
  179.      * )
  180.      */
  181.     private $imageFile;
  183.     /**
  184.      * @ORM\OneToMany(targetEntity=RegistrationClassChange::class, mappedBy="studentRegistration")
  185.      */
  186.     private $registrationClassChanges;
  188.     /**
  189.      * @ORM\OneToMany(targetEntity=RegistrationStudentDowngrade::class, mappedBy="registrationStudentRegistration")
  190.      */
  191.     private $registrationStudentDowngrades;
  193.     /**
  194.      * @ORM\OneToMany(targetEntity=RegistrationStudentAbandonment::class, mappedBy="registrationStudentRegistration")
  195.      */
  196.     private $registrationStudentAbandonments;
  198.     /**
  199.      * @ORM\Column(type="boolean")
  200.     */
  201.     private $is_abandonned;
  203.     /**
  204.      * @ORM\ManyToOne(targetEntity=RegistrationStudentPreRegistration::class, inversedBy="registrationStudentRegistrations")
  205.      */
  206.     private $registrationStudentPreRegistration;
  208.     /**
  209.      * @ORM\OneToMany(targetEntity=RegistrationTransportCheckpoint::class, mappedBy="registrationStudentRegistration")
  210.      */
  211.     private $registrationTransportCheckpoints;
  213.     /**
  214.      * @ORM\Column(type="boolean")
  215.      */
  216.     private $as_food_restrictions;
  218.     /**
  219.      * @ORM\Column(type="boolean")
  220.      */
  221.     private $is_meatless_menu;
  223.     /**
  224.      * @ORM\Column(type="boolean")
  225.      */
  226.     private $is_menu_without_pork;
  228.     /**
  229.      * @ORM\Column(type="boolean")
  230.      */
  231.     private $is_can_eat_alone;
  233.     /**
  234.      * @ORM\Column(type="boolean")
  235.      */
  236.     private $is_can_do_his_business_alone;
  238.     /**
  239.      * @ORM\Column(type="boolean")
  240.      */
  241.     private $is_falls_sleep_easily;
  243.     /**
  244.      * @ORM\OneToMany(targetEntity=SchoolAbsenceAndDelay::class, mappedBy="studentRegistration")
  245.      */
  246.     private $schoolAbsenceAndDelays;
  248.     /**
  249.      * @ORM\ManyToMany(targetEntity=SettingDocumentToProvide::class, inversedBy="registrationStudentRegistrations")
  250.      */
  251.     private $documentProvides;
  253.     /**
  254.      * @ORM\ManyToMany(targetEntity=CommunicationMessage::class, mappedBy="studentRegistrations")
  255.      */
  256.     private $communicationMessages;
  258.     /**
  259.      * @ORM\Column(type="boolean")
  260.     */
  261.     private $is_new;
  263.     /**
  264.      * @ORM\OneToMany(targetEntity=StockStudentKitEntry::class, mappedBy="registrationStudent")
  265.      */
  266.     private $stockStudentKitEntries;
  268.     /**
  269.      * @ORM\OneToMany(targetEntity=StockKitOut::class, mappedBy="registrationStudent")
  270.      */
  271.     private $stockKitOuts;
  273.     /**
  274.      * @ORM\Column(type="string", length=60, nullable=true)
  275.      */
  276.     private $portal_login;
  278.     /**
  279.      * @ORM\Column(type="string", length=60, nullable=true)
  280.      */
  281.     private $portal_password;
  283.     /**
  284.      * @ORM\OneToMany(targetEntity=AccountingCredit::class, mappedBy="studentRegistration")
  285.      */
  286.     private $accountingCredits;
  288.     /**
  289.      * @ORM\OneToMany(targetEntity=SchoolStudentAverage::class, mappedBy="registrationStudentRegistration")
  290.      */
  291.     private $schoolStudentAverages;
  293.     /**
  294.      * @ORM\OneToMany(targetEntity=NurseryTimeSheet::class, mappedBy="registrationStudentRegistration")
  295.      */
  296.     private $nurseryTimeSheets;
  298.     /**
  299.      * @ORM\OneToMany(targetEntity=SchoolTeacherCallSheetLine::class, mappedBy="registrationStudentRegistration")
  300.      */
  301.     private $schoolTeacherCallSheetLines;
  303.     /**
  304.      * @ORM\OneToMany(targetEntity=AccountingChequeTrackingLine::class, mappedBy="registrationStudentRegistration")
  305.      */
  306.     private $accountingChequeTrackingLines;
  308.     /**
  309.      * @ORM\OneToMany(targetEntity=SchoolReportCardAbsence::class, mappedBy="studentRegistration")
  310.      */
  311.     private $schoolReportCardAbsences;
  313.     /**
  314.      * @ORM\OneToMany(targetEntity=WavePayment::class, mappedBy="studentRegistration")
  315.      */
  316.     private $wavePayments;
  318.     /**
  319.      * @ORM\OneToMany(targetEntity=RegistrationStudentContact::class, mappedBy="registrationStudentRegistration")
  320.      */
  321.     private $registrationStudentContacts;
  323.     /**
  324.      * @ORM\OneToMany(targetEntity=TransportCallSheetLine::class, mappedBy="registrationStudentRegistration")
  325.      */
  326.     private $transportCallSheetLines;
  328.     /**
  329.      * @ORM\OneToMany(targetEntity=StockExitSlip::class, mappedBy="registrationStudentRegistration")
  330.      */
  331.     private $stockExitSlips;
  333.     /**
  334.      * @ORM\OneToMany(targetEntity=SchoolAuthorizedPickup::class, mappedBy="studentRegistration")
  335.      */
  336.     private $schoolAuthorizedPickups;
  338.     /**
  339.      * @ORM\Column(type="boolean")
  340.      */
  341.     private $is_authorized_alone;
  343.     /**
  344.      * @ORM\Column(type="string", length=60)
  345.      */
  346.     private $status;
  348.     /**
  349.      * @ORM\Column(type="string", length=32, unique=true, nullable=true)
  350.      */
  351.     private $qr_code;
  353.     public function __construct()
  354.     {
  355.         $this->accountingStudentRegistrationFees = new ArrayCollection();
  356.         $this->schoolReportCards = new ArrayCollection();
  357.         $this->schoolAverageReportCards = new ArrayCollection();
  358.         $this->schoolAssessmentByClasses = new ArrayCollection();
  359.         $this->schoolAssessmentByLevels = new ArrayCollection();
  360.         $this->schoolAssessmentByClassByMatters = new ArrayCollection();
  361.         $this->schoolAssessmentByLevelByMatters = new ArrayCollection();
  362.         $this->is_affected = false;
  363.         $this->is_diet = false;
  364.         $this->is_internal = true;
  365.         $this->is_redoubling = false;
  366.         $this->is_abandonned = false;
  367.         $this->registered_at = new DateTimeImmutable();
  368.         $this->accountingStudentRegistrationPayments = new ArrayCollection();
  369.         $this->registrationClassChanges = new ArrayCollection();
  370.         $this->registrationStudentDowngrades = new ArrayCollection();
  371.         $this->registrationStudentAbandonments = new ArrayCollection();
  372.         $this->registrationTransportCheckpoints = new ArrayCollection();
  374.         $this->as_food_restrictions = false;
  375.         $this->is_meatless_menu = false;
  376.         $this->is_menu_without_pork = false;
  377.         $this->is_can_eat_alone = true;
  378.         $this->is_can_do_his_business_alone = true;
  379.         $this->is_falls_sleep_easily = false;
  380.         $this->schoolAbsenceAndDelays = new ArrayCollection();
  381.         $this->documentProvides = new ArrayCollection();
  382.         $this->communicationMessages = new ArrayCollection();
  384.         $this->is_new = false;
  385.         $this->is_authorized_alone = false;
  386.         $this->stockStudentKitEntries = new ArrayCollection();
  387.         $this->stockKitOuts = new ArrayCollection();
  388.         $this->accountingCredits = new ArrayCollection();
  389.         $this->schoolStudentAverages = new ArrayCollection();
  390.         $this->nurseryTimeSheets = new ArrayCollection();
  391.         $this->schoolTeacherCallSheetLines = new ArrayCollection();
  392.         $this->accountingChequeTrackingLines = new ArrayCollection();
  393.         $this->schoolReportCardAbsences = new ArrayCollection();
  394.         $this->wavePayments = new ArrayCollection();
  395.         $this->registrationStudentContacts = new ArrayCollection();
  396.         $this->transportCallSheetLines = new ArrayCollection();
  397.         $this->stockExitSlips = new ArrayCollection();
  398.         $this->schoolAuthorizedPickups = new ArrayCollection();
  399.         $this->status = self::STATUS_INSCRIT;
  400.     }
  402.     public function getName()
  403.     {
  404.         return $this->getStudent()->getName();
  405.     }
  407.     public function __toString()
  408.     {
  409.         return $this->getName().' ['.$this->getClassroom()->getLabel().']'.' ['.$this->getStudent()->getRegistrationNumber().']';
  410.     }
  412.     /**
  413.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  414.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  415.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  416.      * must be able to accept an instance of 'File' as the bundle will inject one here
  417.      * during Doctrine hydration.
  418.      *
  419.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  420.      */
  421.     public function setImageFile(?File $imageFile = null): void
  422.     {
  423.         $this->imageFile = $imageFile;
  425.         if (null !== $imageFile) {
  426.             // It is required that at least one field changes if you are using doctrine
  427.             // otherwise the event listeners won't be called and the file is lost
  428.             $this->updated_at = new \DateTimeImmutable();
  429.         }
  430.     }
  432.     public function getImageFile(): ?File
  433.     {
  434.         return $this->imageFile;
  435.     }
  437.     public function getId(): ?int
  438.     {
  439.         return $this->id;
  440.     }
  442.     public function getEstablishment(): ?Establishment
  443.     {
  444.         return $this->establishment;
  445.     }
  447.     public function setEstablishment(?Establishment $establishment): self
  448.     {
  449.         $this->establishment = $establishment;
  451.         return $this;
  452.     }
  454.     public function getStudent(): ?RegistrationStudent
  455.     {
  456.         return $this->student;
  457.     }
  459.     public function setStudent(?RegistrationStudent $student): self
  460.     {
  461.         $this->student = $student;
  463.         return $this;
  464.     }
  466.     public function getSchoolYear(): ?SchoolYear
  467.     {
  468.         return $this->schoolYear;
  469.     }
  471.     public function setSchoolYear(?SchoolYear $schoolYear): self
  472.     {
  473.         $this->schoolYear = $schoolYear;
  475.         return $this;
  476.     }
  478.     public function getClassroom(): ?SettingClassroom
  479.     {
  480.         return $this->classroom;
  481.     }
  483.     public function setClassroom(?SettingClassroom $classroom): self
  484.     {
  485.         $this->classroom = $classroom;
  487.         return $this;
  488.     }
  490.     public function getCreatedAt(): ?\DateTimeImmutable
  491.     {
  492.         return $this->created_at;
  493.     }
  495.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  496.     {
  497.         $this->created_at = $created_at;
  499.         return $this;
  500.     }
  502.     public function getUpdatedAt(): ?\DateTimeImmutable
  503.     {
  504.         return $this->updated_at;
  505.     }
  507.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  508.     {
  509.         $this->updated_at = $updated_at;
  511.         return $this;
  512.     }
  514.     public function getCreatedBy(): ?int
  515.     {
  516.         return $this->created_by;
  517.     }
  519.     public function setCreatedBy(int $created_by): self
  520.     {
  521.         $this->created_by = $created_by;
  523.         return $this;
  524.     }
  526.     public function getUpdatedBy(): ?int
  527.     {
  528.         return $this->updated_by;
  529.     }
  531.     public function setUpdatedBy(int $updated_by): self
  532.     {
  533.         $this->updated_by = $updated_by;
  535.         return $this;
  536.     }
  538.     /**
  539.      * @return Collection|AccountingStudentRegistrationFee[]
  540.      */
  541.     public function getAccountingStudentRegistrationFees(): Collection
  542.     {
  543.         return $this->accountingStudentRegistrationFees;
  544.     }
  546.     public function addAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  547.     {
  548.         if (!$this->accountingStudentRegistrationFees->contains($accountingStudentRegistrationFee)) {
  549.             $this->accountingStudentRegistrationFees[] = $accountingStudentRegistrationFee;
  550.             $accountingStudentRegistrationFee->setStudentRegistration($this);
  551.         }
  553.         return $this;
  554.     }
  556.     public function removeAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  557.     {
  558.         if ($this->accountingStudentRegistrationFees->removeElement($accountingStudentRegistrationFee)) {
  559.             // set the owning side to null (unless already changed)
  560.             if ($accountingStudentRegistrationFee->getStudentRegistration() === $this) {
  561.                 $accountingStudentRegistrationFee->setStudentRegistration(null);
  562.             }
  563.         }
  565.         return $this;
  566.     }
  568.     /**
  569.      * @return Collection|SchoolReportCard[]
  570.      */
  571.     public function getSchoolReportCards(): Collection
  572.     {
  573.         return $this->schoolReportCards;
  574.     }
  576.     public function addSchoolReportCard(SchoolReportCard $schoolReportCard): self
  577.     {
  578.         if (!$this->schoolReportCards->contains($schoolReportCard)) {
  579.             $this->schoolReportCards[] = $schoolReportCard;
  580.             $schoolReportCard->setStudentRegistration($this);
  581.         }
  583.         return $this;
  584.     }
  586.    
  587.     public function getOrderedSchoolReportCards(SchoolReportCardRepository $schoolReportCardRepository)
  588.     {
  589.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  590.         ->innerJoin('entity.schoolYearPeriode', 'schoolYearPeriode')
  591.         ->addSelect('schoolYearPeriode')
  593.         ->andWhere('entity.studentRegistration = :studentRegistration')
  594.         ->setParameter('studentRegistration', $this)
  596.         ->orderBy('schoolYearPeriode.code', 'ASC')
  597.         ->getQuery()
  598.         ->getResult();
  600.         return $schoolReportCards;
  601.     }
  603.     public function removeSchoolReportCard(SchoolReportCard $schoolReportCard): self
  604.     {
  605.         if ($this->schoolReportCards->removeElement($schoolReportCard)) {
  606.             // set the owning side to null (unless already changed)
  607.             if ($schoolReportCard->getStudentRegistration() === $this) {
  608.                 $schoolReportCard->setStudentRegistration(null);
  609.             }
  610.         }
  612.         return $this;
  613.     }
  615.     /**
  616.      * @return Collection|SchoolAverageReportCard[]
  617.      */
  618.     public function getSchoolAverageReportCards(): Collection
  619.     {
  620.         return $this->schoolAverageReportCards;
  621.     }
  623.     public function addSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  624.     {
  625.         if (!$this->schoolAverageReportCards->contains($schoolAverageReportCard)) {
  626.             $this->schoolAverageReportCards[] = $schoolAverageReportCard;
  627.             $schoolAverageReportCard->setStudentRegistration($this);
  628.         }
  630.         return $this;
  631.     }
  633.     public function removeSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  634.     {
  635.         if ($this->schoolAverageReportCards->removeElement($schoolAverageReportCard)) {
  636.             // set the owning side to null (unless already changed)
  637.             if ($schoolAverageReportCard->getStudentRegistration() === $this) {
  638.                 $schoolAverageReportCard->setStudentRegistration(null);
  639.             }
  640.         }
  642.         return $this;
  643.     }
  645.     /**
  646.      * @return Collection|SchoolAssessmentByClass[]
  647.      */
  648.     public function getSchoolAssessmentByClasses(): Collection
  649.     {
  650.         return $this->schoolAssessmentByClasses;
  651.     }
  653.     public function addSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  654.     {
  655.         if (!$this->schoolAssessmentByClasses->contains($schoolAssessmentByClass)) {
  656.             $this->schoolAssessmentByClasses[] = $schoolAssessmentByClass;
  657.             $schoolAssessmentByClass->setStudentRegistration($this);
  658.         }
  660.         return $this;
  661.     }
  663.     public function removeSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  664.     {
  665.         if ($this->schoolAssessmentByClasses->removeElement($schoolAssessmentByClass)) {
  666.             // set the owning side to null (unless already changed)
  667.             if ($schoolAssessmentByClass->getStudentRegistration() === $this) {
  668.                 $schoolAssessmentByClass->setStudentRegistration(null);
  669.             }
  670.         }
  672.         return $this;
  673.     }
  675.     /**
  676.      * @return Collection|SchoolAssessmentByLevel[]
  677.      */
  678.     public function getSchoolAssessmentByLevels(): Collection
  679.     {
  680.         return $this->schoolAssessmentByLevels;
  681.     }
  683.     public function addSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  684.     {
  685.         if (!$this->schoolAssessmentByLevels->contains($schoolAssessmentByLevel)) {
  686.             $this->schoolAssessmentByLevels[] = $schoolAssessmentByLevel;
  687.             $schoolAssessmentByLevel->setStudentRegistration($this);
  688.         }
  690.         return $this;
  691.     }
  693.     public function removeSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  694.     {
  695.         if ($this->schoolAssessmentByLevels->removeElement($schoolAssessmentByLevel)) {
  696.             // set the owning side to null (unless already changed)
  697.             if ($schoolAssessmentByLevel->getStudentRegistration() === $this) {
  698.                 $schoolAssessmentByLevel->setStudentRegistration(null);
  699.             }
  700.         }
  702.         return $this;
  703.     }
  705.     /**
  706.      * @return Collection|SchoolAssessmentByClassByMatter[]
  707.      */
  708.     public function getSchoolAssessmentByClassByMatters(): Collection
  709.     {
  710.         return $this->schoolAssessmentByClassByMatters;
  711.     }
  713.     public function addSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  714.     {
  715.         if (!$this->schoolAssessmentByClassByMatters->contains($schoolAssessmentByClassByMatter)) {
  716.             $this->schoolAssessmentByClassByMatters[] = $schoolAssessmentByClassByMatter;
  717.             $schoolAssessmentByClassByMatter->setStudentRegistration($this);
  718.         }
  720.         return $this;
  721.     }
  723.     public function removeSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  724.     {
  725.         if ($this->schoolAssessmentByClassByMatters->removeElement($schoolAssessmentByClassByMatter)) {
  726.             // set the owning side to null (unless already changed)
  727.             if ($schoolAssessmentByClassByMatter->getStudentRegistration() === $this) {
  728.                 $schoolAssessmentByClassByMatter->setStudentRegistration(null);
  729.             }
  730.         }
  732.         return $this;
  733.     }
  735.     /**
  736.      * @return Collection|SchoolAssessmentByLevelByMatter[]
  737.      */
  738.     public function getSchoolAssessmentByLevelByMatters(): Collection
  739.     {
  740.         return $this->schoolAssessmentByLevelByMatters;
  741.     }
  743.     public function addSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  744.     {
  745.         if (!$this->schoolAssessmentByLevelByMatters->contains($schoolAssessmentByLevelByMatter)) {
  746.             $this->schoolAssessmentByLevelByMatters[] = $schoolAssessmentByLevelByMatter;
  747.             $schoolAssessmentByLevelByMatter->setStudentRegistration($this);
  748.         }
  750.         return $this;
  751.     }
  753.     public function removeSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  754.     {
  755.         if ($this->schoolAssessmentByLevelByMatters->removeElement($schoolAssessmentByLevelByMatter)) {
  756.             // set the owning side to null (unless already changed)
  757.             if ($schoolAssessmentByLevelByMatter->getStudentRegistration() === $this) {
  758.                 $schoolAssessmentByLevelByMatter->setStudentRegistration(null);
  759.             }
  760.         }
  762.         return $this;
  763.     }
  765.     public function getIsRedoubling(): ?bool
  766.     {
  767.         return $this->is_redoubling;
  768.     }
  770.     public function setIsRedoubling(bool $is_redoubling): self
  771.     {
  772.         $this->is_redoubling = $is_redoubling;
  774.         return $this;
  775.     }
  777.     public function getIsDiet(): ?bool
  778.     {
  779.         return $this->is_diet;
  780.     }
  782.     public function setIsDiet(bool $is_diet): self
  783.     {
  784.         $this->is_diet = $is_diet;
  786.         return $this;
  787.     }
  789.     public function getIsInternal(): ?bool
  790.     {
  791.         return $this->is_internal;
  792.     }
  794.     public function setIsInternal(bool $is_internal): self
  795.     {
  796.         $this->is_internal = $is_internal;
  798.         return $this;
  799.     }
  801.     public function getIsAffected(): ?bool
  802.     {
  803.         return $this->is_affected;
  804.     }
  806.     public function setIsAffected(bool $is_affected): self
  807.     {
  808.         $this->is_affected = $is_affected;
  810.         return $this;
  811.     }
  813.     public function getRegisteredAt(): ?\DateTimeImmutable
  814.     {
  815.         return $this->registered_at;
  816.     }
  818.     public function setRegisteredAt(\DateTimeImmutable $registered_at): self
  819.     {
  820.         $this->registered_at = $registered_at;
  822.         return $this;
  823.     }
  825.     public function getGleAmount(){
  826.         $amount = 0;
  827.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $fee) {
  828.             if (!$fee->getIsArchived()) {
  829.                 $amount = $amount + $fee->getAmount();
  830.             }
  831.         }
  833.         return $amount;
  834.     }
  836.     public function getAmountPaid(){
  837.         $amount = 0;
  838.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  839.             //if (!$accountingStudentRegistrationPayment->isCanBeShow()) {
  840.                 $amount = $amount + $accountingStudentRegistrationPayment->getAmount();
  841.             //}
  842.         }
  844.         $payArchived = 0;
  845.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  846.             if ($accountingStudentRegistrationFee->getIsArchived()) {
  847.                 $payArchived = $payArchived + $accountingStudentRegistrationFee->getAmountPaid();
  848.             }
  849.             
  850.         }
  853.         return $amount - $payArchived;
  854.     }
  856.     public function getAmountCancel(): ?float
  857.     {
  858.         $amountCancel = 0;
  859.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  860.             //if (!$accountingStudentRegistrationFee->getIsArchived()) {
  861.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountReported();
  862.             //}
  863.         }
  864.         
  865.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  866.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  867.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountCancel();
  868.             }
  869.         }
  870.         
  871.         return $amountCancel;
  872.     }
  874.     public function getAmountRest(): ?float
  875.     {
  876.         $amount = ($this->getGleAmount() - ($this->getAmountPaid() + $this->getAmountCancel()));
  877.         return $amount > 0 ? $amount : 0;
  878.     }
  880.     /**
  881.      * @return Collection|AccountingStudentRegistrationPayment[]
  882.      */
  883.     public function getAccountingStudentRegistrationPayments(): Collection
  884.     {
  885.         return $this->accountingStudentRegistrationPayments;
  886.     }
  888.     public function addAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  889.     {
  890.         if (!$this->accountingStudentRegistrationPayments->contains($accountingStudentRegistrationPayment)) {
  891.             $this->accountingStudentRegistrationPayments[] = $accountingStudentRegistrationPayment;
  892.             $accountingStudentRegistrationPayment->setStudentRegistration($this);
  893.         }
  895.         return $this;
  896.     }
  898.     public function removeAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  899.     {
  900.         if ($this->accountingStudentRegistrationPayments->removeElement($accountingStudentRegistrationPayment)) {
  901.             // set the owning side to null (unless already changed)
  902.             if ($accountingStudentRegistrationPayment->getStudentRegistration() === $this) {
  903.                 $accountingStudentRegistrationPayment->setStudentRegistration(null);
  904.             }
  905.         }
  907.         return $this;
  908.     }
  910.     public function getLastAmountPaid(): ?float
  911.     {
  912.         return $this->last_amount_paid;
  913.     }
  915.     public function setLastAmountPaid(?float $last_amount_paid): self
  916.     {
  917.         $this->last_amount_paid = $last_amount_paid;
  919.         return $this;
  920.     }
  922.     public function getLastPaymentId(): ?int
  923.     {
  924.         return $this->last_payment_id;
  925.     }
  927.     public function setLastPaymentId(?int $last_payment_id): self
  928.     {
  929.         $this->last_payment_id = $last_payment_id;
  931.         return $this;
  932.     }
  934.     public function getLastPaymentAt(): ?\DateTimeImmutable
  935.     {
  936.         return $this->last_payment_at;
  937.     }
  939.     public function setLastPaymentAt(?\DateTimeImmutable $last_payment_at): self
  940.     {
  941.         $this->last_payment_at = $last_payment_at;
  943.         return $this;
  944.     }
  946.     public function getImage(): ?string
  947.     {
  948.         return $this->image;
  949.     }
  951.     public function setImage(?string $image): self
  952.     {
  953.         $this->image = $image;
  955.         return $this;
  956.     }
  958.     /**
  959.      * @return Collection|RegistrationClassChange[]
  960.      */
  961.     public function getRegistrationClassChanges(): Collection
  962.     {
  963.         return $this->registrationClassChanges;
  964.     }
  966.     public function addRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  967.     {
  968.         if (!$this->registrationClassChanges->contains($registrationClassChange)) {
  969.             $this->registrationClassChanges[] = $registrationClassChange;
  970.             $registrationClassChange->setStudentRegistration($this);
  971.         }
  973.         return $this;
  974.     }
  976.     public function removeRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  977.     {
  978.         if ($this->registrationClassChanges->removeElement($registrationClassChange)) {
  979.             // set the owning side to null (unless already changed)
  980.             if ($registrationClassChange->getStudentRegistration() === $this) {
  981.                 $registrationClassChange->setStudentRegistration(null);
  982.             }
  983.         }
  985.         return $this;
  986.     }
  988.     /**
  989.      * @return Collection|RegistrationStudentDowngrade[]
  990.      */
  991.     public function getRegistrationStudentDowngrades(): Collection
  992.     {
  993.         return $this->registrationStudentDowngrades;
  994.     }
  996.     public function addRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  997.     {
  998.         if (!$this->registrationStudentDowngrades->contains($registrationStudentDowngrade)) {
  999.             $this->registrationStudentDowngrades[] = $registrationStudentDowngrade;
  1000.             $registrationStudentDowngrade->setRegistrationStudentRegistration($this);
  1001.         }
  1003.         return $this;
  1004.     }
  1006.     public function removeRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  1007.     {
  1008.         if ($this->registrationStudentDowngrades->removeElement($registrationStudentDowngrade)) {
  1009.             // set the owning side to null (unless already changed)
  1010.             if ($registrationStudentDowngrade->getRegistrationStudentRegistration() === $this) {
  1011.                 $registrationStudentDowngrade->setRegistrationStudentRegistration(null);
  1012.             }
  1013.         }
  1015.         return $this;
  1016.     }
  1018.     /**
  1019.      * @return Collection|RegistrationStudentAbandonment[]
  1020.      */
  1021.     public function getRegistrationStudentAbandonments(): Collection
  1022.     {
  1023.         return $this->registrationStudentAbandonments;
  1024.     }
  1026.     public function addRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1027.     {
  1028.         if (!$this->registrationStudentAbandonments->contains($registrationStudentAbandonment)) {
  1029.             $this->registrationStudentAbandonments[] = $registrationStudentAbandonment;
  1030.             $registrationStudentAbandonment->setRegistrationStudentRegistration($this);
  1031.         }
  1033.         return $this;
  1034.     }
  1036.     public function removeRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1037.     {
  1038.         if ($this->registrationStudentAbandonments->removeElement($registrationStudentAbandonment)) {
  1039.             // set the owning side to null (unless already changed)
  1040.             if ($registrationStudentAbandonment->getRegistrationStudentRegistration() === $this) {
  1041.                 $registrationStudentAbandonment->setRegistrationStudentRegistration(null);
  1042.             }
  1043.         }
  1045.         return $this;
  1046.     }
  1048.     public function getIsAbandonned(): ?bool
  1049.     {
  1050.         return $this->is_abandonned;
  1051.     }
  1053.     public function setIsAbandonned(bool $is_abandonned): self
  1054.     {
  1055.         $this->is_abandonned = $is_abandonned;
  1057.         return $this;
  1058.     }
  1060.     public function getRegistrationStudentPreRegistration(): ?RegistrationStudentPreRegistration
  1061.     {
  1062.         return $this->registrationStudentPreRegistration;
  1063.     }
  1065.     public function setRegistrationStudentPreRegistration(?RegistrationStudentPreRegistration $registrationStudentPreRegistration): self
  1066.     {
  1067.         $this->registrationStudentPreRegistration = $registrationStudentPreRegistration;
  1069.         return $this;
  1070.     }
  1072.     /**
  1073.      * @return Collection|RegistrationTransportCheckpoint[]
  1074.      */
  1075.     public function getRegistrationTransportCheckpoints(): Collection
  1076.     {
  1077.         return $this->registrationTransportCheckpoints;
  1078.     }
  1080.     public function addRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1081.     {
  1082.         if (!$this->registrationTransportCheckpoints->contains($registrationTransportCheckpoint)) {
  1083.             $this->registrationTransportCheckpoints[] = $registrationTransportCheckpoint;
  1084.             $registrationTransportCheckpoint->setRegistrationStudentRegistration($this);
  1085.         }
  1087.         return $this;
  1088.     }
  1090.     public function removeRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1091.     {
  1092.         if ($this->registrationTransportCheckpoints->removeElement($registrationTransportCheckpoint)) {
  1093.             // set the owning side to null (unless already changed)
  1094.             if ($registrationTransportCheckpoint->getRegistrationStudentRegistration() === $this) {
  1095.                 $registrationTransportCheckpoint->setRegistrationStudentRegistration(null);
  1096.             }
  1097.         }
  1099.         return $this;
  1100.     }
  1102.     public function hasTransportFee(){
  1103.         $reponse = false;
  1104.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1105.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::TRANSPORT_FEE && !$accountingStudentRegistrationFee->getIsCancel() && $accountingStudentRegistrationFee->getAmountPaid() > 0 && !$accountingStudentRegistrationFee->getIsArchived()) {
  1106.                 $reponse = true;
  1107.                 break;
  1108.             }
  1109.         }
  1111.         return $reponse;
  1112.     }
  1114.     public function hasGardeMidiFee(){
  1115.         $reponse = false;
  1116.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1117.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::GARDE_MIDI_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1118.                 $reponse = true;
  1119.                 break;
  1120.             }
  1121.         }
  1123.         return $reponse;
  1124.     }
  1126.     public function hasExtraFee(){
  1127.         $reponse = false;
  1128.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1129.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::ACTIVITE_EXTAT_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1130.                 $reponse = true;
  1131.                 break;
  1132.             }
  1133.         }
  1135.         return $reponse;
  1136.     }
  1138.     public function hasCanteenFee(){
  1139.         $reponse = false;
  1140.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1141.             if($accountingStudentRegistrationFee->getFee()->getSchoolYear() == $this->getSchoolYear()) {
  1142.                 if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::CANTINE_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1143.                     $reponse = true;
  1144.                     break;
  1145.                 }
  1146.             }
  1147.         }
  1149.         return $reponse;
  1150.     }
  1152.     public function hasMobileApp(){
  1153.         $reponse = false;
  1154.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1155.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::MOBILE_APP && !$accountingStudentRegistrationFee->getIsCancel()) {
  1156.                 $reponse = true;
  1157.                 break;
  1158.             }
  1159.         }
  1161.         return $reponse;
  1162.     }
  1164.     public function getAmountDueAt(DateTimeImmutable $dueDate, $category = '0'){
  1165.         
  1166.         $amountDue = 0;
  1167.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1168.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1169.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1170.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() >= 0) {
  1171.                         if ('0' != $category) {
  1172.                             if ($accountingStudentRegistrationFee->getFee()->getCategory() == $category) {
  1173.                                 $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1174.                             }
  1175.                         }else {
  1176.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1177.                         }
  1178.                     }
  1179.                 }
  1180.             }
  1181.         }
  1183.         $amountChequeTracking = 0;
  1184.         foreach ($this->getAccountingChequeTrackingLines() as $key => $accountingChequeTrackingLine) {
  1185.             if ($accountingChequeTrackingLine->getAccountingChequeTracking()->getStatus() == AccountingChequeTracking::EN_TRAITEMENT) {
  1186.                 $amountChequeTracking += $accountingChequeTrackingLine->getAmount();
  1187.             }
  1188.         }
  1189.         
  1190.         return $amountDue - $amountChequeTracking;
  1191.     }
  1193.     public function getAmountDueAtByFee(DateTimeImmutable $dueDate, SettingFee $settingFee){
  1194.         
  1195.         $amountDue = 0;
  1196.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1197.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1198.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1199.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1200.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1201.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1202.                         }
  1203.                     }
  1204.                 }
  1205.             }
  1206.         }
  1207.         
  1208.         return $amountDue;
  1209.     }
  1211.     public function getAmountByFee(SettingFee $settingFee){
  1212.         
  1213.         $amountDue = 0;
  1214.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1215.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1216.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1217.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1218.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1219.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmount();
  1220.                         }
  1221.                     //}
  1222.                 }
  1223.             }
  1224.         }
  1225.         
  1226.         return $amountDue;
  1227.     }
  1229.     public function getAmountPaidByFee(SettingFee $settingFee){
  1230.         
  1231.         $amountDue = 0;
  1232.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1233.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1234.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1235.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1236.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1237.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountPaid();
  1238.                         }
  1239.                     //}
  1240.                 }
  1241.             }
  1242.         }
  1243.         
  1244.         return $amountDue;
  1245.     }
  1247.     public function getAmountRestByFee(SettingFee $settingFee){
  1248.         
  1249.         $amountDue = 0;
  1250.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1251.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1252.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1253.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1254.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1255.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1256.                         }
  1257.                     //}
  1258.                 }
  1259.             }
  1260.         }
  1261.         
  1262.         return $amountDue;
  1263.     }
  1265.     public function getFeeShedulDues(DateTimeImmutable $dueDate){
  1266.         $feeShedulDues = new ArrayCollection();
  1267.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1268.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1269.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1270.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1271.                         $feeShedulDues->add($accountingStudentRegistrationFeeShedul);
  1272.                     }
  1273.                 }
  1274.             }
  1275.         }
  1276.         
  1277.         return $feeShedulDues;
  1278.     }
  1280.     public function getAsFoodRestrictions(): ?bool
  1281.     {
  1282.         return $this->as_food_restrictions;
  1283.     }
  1285.     public function setAsFoodRestrictions(bool $as_food_restrictions): self
  1286.     {
  1287.         $this->as_food_restrictions = $as_food_restrictions;
  1289.         return $this;
  1290.     }
  1292.     public function getIsMeatlessMenu(): ?bool
  1293.     {
  1294.         return $this->is_meatless_menu;
  1295.     }
  1297.     public function setIsMeatlessMenu(bool $is_meatless_menu): self
  1298.     {
  1299.         $this->is_meatless_menu = $is_meatless_menu;
  1301.         return $this;
  1302.     }
  1304.     public function getIsMenuWithoutPork(): ?bool
  1305.     {
  1306.         return $this->is_menu_without_pork;
  1307.     }
  1309.     public function setIsMenuWithoutPork(bool $is_menu_without_pork): self
  1310.     {
  1311.         $this->is_menu_without_pork = $is_menu_without_pork;
  1313.         return $this;
  1314.     }
  1316.     public function getIsCanEatAlone(): ?bool
  1317.     {
  1318.         return $this->is_can_eat_alone;
  1319.     }
  1321.     public function setIsCanEatAlone(bool $is_can_eat_alone): self
  1322.     {
  1323.         $this->is_can_eat_alone = $is_can_eat_alone;
  1325.         return $this;
  1326.     }
  1328.     public function getIsCanDoHisBusinessAlone(): ?bool
  1329.     {
  1330.         return $this->is_can_do_his_business_alone;
  1331.     }
  1333.     public function setIsCanDoHisBusinessAlone(bool $is_can_do_his_business_alone): self
  1334.     {
  1335.         $this->is_can_do_his_business_alone = $is_can_do_his_business_alone;
  1337.         return $this;
  1338.     }
  1340.     public function getIsFallsSleepEasily(): ?bool
  1341.     {
  1342.         return $this->is_falls_sleep_easily;
  1343.     }
  1345.     public function setIsFallsSleepEasily(bool $is_falls_sleep_easily): self
  1346.     {
  1347.         $this->is_falls_sleep_easily = $is_falls_sleep_easily;
  1349.         return $this;
  1350.     }
  1352.     /**
  1353.      * @return Collection|SchoolAbsenceAndDelay[]
  1354.      */
  1355.     public function getSchoolAbsenceAndDelays(): Collection
  1356.     {
  1357.         return $this->schoolAbsenceAndDelays;
  1358.     }
  1360.     public function addSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1361.     {
  1362.         if (!$this->schoolAbsenceAndDelays->contains($schoolAbsenceAndDelay)) {
  1363.             $this->schoolAbsenceAndDelays[] = $schoolAbsenceAndDelay;
  1364.             $schoolAbsenceAndDelay->setStudentRegistration($this);
  1365.         }
  1367.         return $this;
  1368.     }
  1370.     public function removeSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1371.     {
  1372.         if ($this->schoolAbsenceAndDelays->removeElement($schoolAbsenceAndDelay)) {
  1373.             // set the owning side to null (unless already changed)
  1374.             if ($schoolAbsenceAndDelay->getStudentRegistration() === $this) {
  1375.                 $schoolAbsenceAndDelay->setStudentRegistration(null);
  1376.             }
  1377.         }
  1379.         return $this;
  1380.     }
  1382.     public function getDelayByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1383.         $minute = 0;
  1384.         $heure = 0;
  1385.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1386.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1387.                 if ($schoolAbsenceAndDelay->getSituation() == 'RETARD') {
  1388.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1389.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1390.                     }
  1392.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1393.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1394.                     }
  1395.                 }
  1396.             }
  1397.         }
  1399.         $heure = ceil($heure + ($minute / 60));
  1400.         
  1401.         return $heure;
  1402.     }
  1404.     public function getAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1405.         $minute = 0;
  1406.         $heure = 0;
  1407.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1408.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1409.                 if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1410.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1411.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1412.                     }
  1414.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1415.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1416.                     }
  1417.                 }
  1418.             }
  1419.         }
  1421.         $heure = ceil($heure + ($minute / 60));
  1422.         
  1423.         return $heure;
  1424.     }
  1426.     /**
  1427.      * @return Collection|SettingDocumentToProvide[]
  1428.      */
  1429.     public function getDocumentProvides(): Collection
  1430.     {
  1431.         return $this->documentProvides;
  1432.     }
  1434.     public function addDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1435.     {
  1436.         if (!$this->documentProvides->contains($documentProvide)) {
  1437.             $this->documentProvides[] = $documentProvide;
  1438.         }
  1440.         return $this;
  1441.     }
  1443.     public function removeDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1444.     {
  1445.         $this->documentProvides->removeElement($documentProvide);
  1447.         return $this;
  1448.     }
  1450.     /**
  1451.      * @return Collection|CommunicationMessage[]
  1452.      */
  1453.     public function getCommunicationMessages(): Collection
  1454.     {
  1455.         return $this->communicationMessages;
  1456.     }
  1458.     public function addCommunicationMessage(CommunicationMessage $communicationMessage): self
  1459.     {
  1460.         if (!$this->communicationMessages->contains($communicationMessage)) {
  1461.             $this->communicationMessages[] = $communicationMessage;
  1462.             $communicationMessage->addStudentRegistration($this);
  1463.         }
  1465.         return $this;
  1466.     }
  1468.     public function removeCommunicationMessage(CommunicationMessage $communicationMessage): self
  1469.     {
  1470.         if ($this->communicationMessages->removeElement($communicationMessage)) {
  1471.             $communicationMessage->removeStudentRegistration($this);
  1472.         }
  1474.         return $this;
  1475.     }
  1477.     public function getIsNew(): ?bool
  1478.     {
  1479.         return $this->is_new;
  1480.     }
  1482.     public function setIsNew(bool $is_new): self
  1483.     {
  1484.         $this->is_new = $is_new;
  1486.         return $this;
  1487.     }
  1489.     /**
  1490.      * @return Collection|StockStudentKitEntry[]
  1491.      */
  1492.     public function getStockStudentKitEntries(): Collection
  1493.     {
  1494.         return $this->stockStudentKitEntries;
  1495.     }
  1497.     public function addStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1498.     {
  1499.         if (!$this->stockStudentKitEntries->contains($stockStudentKitEntry)) {
  1500.             $this->stockStudentKitEntries[] = $stockStudentKitEntry;
  1501.             $stockStudentKitEntry->setRegistrationStudent($this);
  1502.         }
  1504.         return $this;
  1505.     }
  1507.     public function removeStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1508.     {
  1509.         if ($this->stockStudentKitEntries->removeElement($stockStudentKitEntry)) {
  1510.             // set the owning side to null (unless already changed)
  1511.             if ($stockStudentKitEntry->getRegistrationStudent() === $this) {
  1512.                 $stockStudentKitEntry->setRegistrationStudent(null);
  1513.             }
  1514.         }
  1516.         return $this;
  1517.     }
  1519.     /**
  1520.      * @return Collection|StockKitOut[]
  1521.      */
  1522.     public function getStockKitOuts(): Collection
  1523.     {
  1524.         return $this->stockKitOuts;
  1525.     }
  1527.     public function addStockKitOut(StockKitOut $stockKitOut): self
  1528.     {
  1529.         if (!$this->stockKitOuts->contains($stockKitOut)) {
  1530.             $this->stockKitOuts[] = $stockKitOut;
  1531.             $stockKitOut->setRegistrationStudent($this);
  1532.         }
  1534.         return $this;
  1535.     }
  1537.     public function removeStockKitOut(StockKitOut $stockKitOut): self
  1538.     {
  1539.         if ($this->stockKitOuts->removeElement($stockKitOut)) {
  1540.             // set the owning side to null (unless already changed)
  1541.             if ($stockKitOut->getRegistrationStudent() === $this) {
  1542.                 $stockKitOut->setRegistrationStudent(null);
  1543.             }
  1544.         }
  1546.         return $this;
  1547.     }
  1549.     public function getPortalLogin(): ?string
  1550.     {
  1551.         return $this->portal_login;
  1552.     }
  1554.     public function setPortalLogin(?string $portal_login): self
  1555.     {
  1556.         $this->portal_login = $portal_login;
  1558.         return $this;
  1559.     }
  1561.     public function getPortalPassword(): ?string
  1562.     {
  1563.         return $this->portal_password;
  1564.     }
  1566.     public function setPortalPassword(?string $portal_password): self
  1567.     {
  1568.         $this->portal_password = $portal_password;
  1570.         return $this;
  1571.     }
  1573.     /**
  1574.      * @return Collection|AccountingCredit[]
  1575.      */
  1576.     public function getAccountingCredits(): Collection
  1577.     {
  1578.         return $this->accountingCredits;
  1579.     }
  1581.     public function addAccountingCredit(AccountingCredit $accountingCredit): self
  1582.     {
  1583.         if (!$this->accountingCredits->contains($accountingCredit)) {
  1584.             $this->accountingCredits[] = $accountingCredit;
  1585.             $accountingCredit->setStudentRegistration($this);
  1586.         }
  1588.         return $this;
  1589.     }
  1591.     public function removeAccountingCredit(AccountingCredit $accountingCredit): self
  1592.     {
  1593.         if ($this->accountingCredits->removeElement($accountingCredit)) {
  1594.             // set the owning side to null (unless already changed)
  1595.             if ($accountingCredit->getStudentRegistration() === $this) {
  1596.                 $accountingCredit->setStudentRegistration(null);
  1597.             }
  1598.         }
  1600.         return $this;
  1601.     }
  1603.     /**
  1604.      * @return Collection|SchoolStudentAverage[]
  1605.      */
  1606.     public function getSchoolStudentAverages(): Collection
  1607.     {
  1608.         return $this->schoolStudentAverages;
  1609.     }
  1611.     public function addSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1612.     {
  1613.         if (!$this->schoolStudentAverages->contains($schoolStudentAverage)) {
  1614.             $this->schoolStudentAverages[] = $schoolStudentAverage;
  1615.             $schoolStudentAverage->setRegistrationStudentRegistration($this);
  1616.         }
  1618.         return $this;
  1619.     }
  1621.     public function removeSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1622.     {
  1623.         if ($this->schoolStudentAverages->removeElement($schoolStudentAverage)) {
  1624.             // set the owning side to null (unless already changed)
  1625.             if ($schoolStudentAverage->getRegistrationStudentRegistration() === $this) {
  1626.                 $schoolStudentAverage->setRegistrationStudentRegistration(null);
  1627.             }
  1628.         }
  1630.         return $this;
  1631.     }
  1633.     public function computePeriodeAverage(SchoolMatter $schoolMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1634.         if (count($schoolMatter->getSchoolSubMatters()) > 0) {
  1635.             $averages = 0;
  1636.             $periodeAverage = 0;
  1637.             $count = 0;
  1638.             $coeffecient = 0;
  1639.             foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1640.                 $_averages = 0;
  1641.                 $_periodeAverage = 0;
  1642.                 $_count = 0;
  1643.                 $_coeffecient = 0;
  1644.                 foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1645.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  1646.                         if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1647.                             $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1648.                             if (!$schoolStudentAverage->getIsUnclassified()) {
  1649.                                 if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1650.                                     if ($schoolStudentAverage->getSubMatter() != null) {
  1651.                                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1652.                                             $_count ++;
  1653.                                             if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1654.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1655.                                                     $averages += $schoolStudentAverage->getNote();
  1656.                                                     //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1657.                                                     $_coeffecient += 1;
  1658.                                                 }
  1659.                                             }else {
  1660.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1661.                                                     //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getSubMatter()->getCoefficient();
  1662.                                                     //$coeffecient += $schoolStudentAverage->getSubMatter()->getCoefficient();
  1663.                                                     $_averages += $schoolStudentAverage->getNote();
  1664.                                                     $_coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1665.                                                 }
  1666.                                             }
  1667.                                         }
  1668.                                     }
  1669.                                 }
  1670.                             }
  1671.                         }
  1672.                     }
  1673.                 }
  1674.                 
  1675.                 if ($_coeffecient > 0) {
  1676.                     $_periodeAverage = $_averages / $_coeffecient;
  1677.                     $averages += ($_periodeAverage * $schoolSubMatter->getCoefficient()); 
  1678.                     $coeffecient += $schoolSubMatter->getCoefficient(); 
  1679.                 }else {
  1680.                     $_periodeAverage = 999;
  1681.                 }
  1682.             }
  1684.             if ($coeffecient > 0) {
  1685.                 $periodeAverage = $averages / $coeffecient;
  1686.             }else {
  1687.                 $periodeAverage = 999;
  1688.             }
  1690.             return $periodeAverage;
  1691.         }else {
  1692.             $averages = 0;
  1693.             $periodeAverage = 0;
  1694.             $count = 0;
  1695.             $coeffecient = 0;
  1696.             foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1697.                 if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1698.                     $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1699.                     if (!$schoolStudentAverage->getIsUnclassified()) {
  1700.                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1701.                             if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1702.                                 $count++;
  1703.                                 if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1704.                                     if($schoolStudentAverage->getNote() < 999.0){
  1705.                                         $averages += $schoolStudentAverage->getNote();
  1706.                                         //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1707.                                         $coeffecient += 1;
  1708.                                     }
  1709.                                 }else {
  1710.                                     if($schoolStudentAverage->getNote() < 999.0){
  1711.                                         //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getMatter()->getCoefficient();
  1712.                                         //$coeffecient += $schoolStudentAverage->getMatter()->getCoefficient();
  1713.                                         
  1714.                                         $averages += $schoolStudentAverage->getNote();
  1715.                                         $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1716.                                     }
  1717.                                 }
  1718.                             }
  1719.                         }
  1720.                     }
  1721.                 }
  1722.             }
  1723.             
  1724.             if ($coeffecient > 0) {
  1725.                 $periodeAverage = $averages / $coeffecient;
  1726.             }else {
  1727.                 $periodeAverage = 999;
  1728.             }
  1730.             return $periodeAverage;
  1731.         }
  1732.     }
  1734.     public function computeSubPeriodeAverage(SchoolSubMatter $schoolSubMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1735.         $averages = 0;
  1736.         $periodeAverage = 0;
  1737.         $count = 0;
  1738.         $coeffecient = 0;
  1739.         
  1740.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1741.             if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1742.                 $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1743.                 if (!$schoolStudentAverage->getIsUnclassified()) {
  1744.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1745.                         $count++;
  1746.                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1747.                             if($schoolStudentAverage->getNote() < 999){
  1748.                                 $averages += $schoolStudentAverage->getNote();
  1749.                                 //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1750.                                 $coeffecient += 1;
  1751.                             }
  1752.                         }else {
  1753.                             if($schoolStudentAverage->getNote() < 999){
  1754.                                 //$averages += $schoolStudentAverage->getNote() * $schoolSubMatter->getCoefficient();
  1755.                                 //$coeffecient += $schoolSubMatter->getCoefficient();
  1757.                                 $averages += $schoolStudentAverage->getNote();
  1758.                                 $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1759.                             }
  1760.                         }
  1761.                         
  1762.                     }
  1763.                 }
  1764.             }
  1765.         }
  1766.         
  1767.         if ($coeffecient > 0) {
  1768.             $periodeAverage = $averages / $coeffecient;
  1769.         }else {
  1770.             $periodeAverage = 999;
  1771.         }
  1773.         return $periodeAverage;
  1774.     }
  1776.     public function asMatterDone(SchoolMatter $schoolMatter, ReportCard $reportCard){
  1777.         
  1778.         $count = 0;
  1779.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1780.             if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1781.                 
  1782.                 $count++;
  1783.             }
  1784.         }
  1786.         return $count > 0;
  1787.     }
  1789.     public function getAnnualAverage(): ?float
  1790.     {
  1791.         $annual_average = 0;
  1792.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1793.             $annual_average = $schoolReportCard->getAnnualAverage();
  1794.         }
  1795.         return $annual_average;
  1796.     }
  1798.     public function getAnnualRank(): ?string
  1799.     {
  1800.         $annual_rank = 0;
  1801.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1802.             $annual_rank = $schoolReportCard->getAnnualRank();
  1803.         }
  1804.         return $annual_rank;
  1805.     }
  1807.     /**
  1808.      * @return Collection|NurseryTimeSheet[]
  1809.      */
  1810.     public function getNurseryTimeSheets(): Collection
  1811.     {
  1812.         return $this->nurseryTimeSheets;
  1813.     }
  1815.     public function addNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1816.     {
  1817.         if (!$this->nurseryTimeSheets->contains($nurseryTimeSheet)) {
  1818.             $this->nurseryTimeSheets[] = $nurseryTimeSheet;
  1819.             $nurseryTimeSheet->setRegistrationStudentRegistration($this);
  1820.         }
  1822.         return $this;
  1823.     }
  1825.     public function removeNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1826.     {
  1827.         if ($this->nurseryTimeSheets->removeElement($nurseryTimeSheet)) {
  1828.             // set the owning side to null (unless already changed)
  1829.             if ($nurseryTimeSheet->getRegistrationStudentRegistration() === $this) {
  1830.                 $nurseryTimeSheet->setRegistrationStudentRegistration(null);
  1831.             }
  1832.         }
  1834.         return $this;
  1835.     }
  1837.     /**
  1838.      * @return Collection|SchoolTeacherCallSheetLine[]
  1839.      */
  1840.     public function getSchoolTeacherCallSheetLines(): Collection
  1841.     {
  1842.         return $this->schoolTeacherCallSheetLines;
  1843.     }
  1845.     public function addSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1846.     {
  1847.         if (!$this->schoolTeacherCallSheetLines->contains($schoolTeacherCallSheetLine)) {
  1848.             $this->schoolTeacherCallSheetLines[] = $schoolTeacherCallSheetLine;
  1849.             $schoolTeacherCallSheetLine->setRegistrationStudentRegistration($this);
  1850.         }
  1852.         return $this;
  1853.     }
  1855.     public function removeSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1856.     {
  1857.         if ($this->schoolTeacherCallSheetLines->removeElement($schoolTeacherCallSheetLine)) {
  1858.             // set the owning side to null (unless already changed)
  1859.             if ($schoolTeacherCallSheetLine->getRegistrationStudentRegistration() === $this) {
  1860.                 $schoolTeacherCallSheetLine->setRegistrationStudentRegistration(null);
  1861.             }
  1862.         }
  1864.         return $this;
  1865.     }
  1867.     public function getJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1868.         $minute = 0;
  1869.         $heure = 0;
  1870.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1871.             if ($schoolAbsenceAndDelay->getIsJustify()) {
  1872.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1873.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1874.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1875.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1876.                         }
  1878.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1879.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1880.                         }
  1881.                     }
  1882.                 }
  1883.             }
  1884.         }
  1886.         $heure = ceil($heure + ($minute / 60));
  1887.         
  1888.         return $heure;
  1889.     }
  1891.     public function getNotJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1892.         $minute = 0;
  1893.         $heure = 0;
  1894.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1895.             if (!$schoolAbsenceAndDelay->getIsJustify()) {
  1896.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1897.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1898.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1899.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1900.                         }
  1902.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1903.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1904.                         }
  1905.                     }
  1906.                 }
  1907.             }
  1908.         }
  1910.         $heure = ceil($heure + ($minute / 60));
  1911.         
  1912.         return $heure;
  1913.     }
  1915.     public function isReported(){
  1916.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1917.             if ($accountingStudentRegistrationFee->getIsReported()) {
  1918.                 return true;
  1919.                 break;
  1920.             }
  1921.         }
  1923.         return false;
  1924.     }
  1926.     public function getNurseryPresence(DateTimeImmutable $startDate, DateTimeImmutable $endDate){
  1927.         
  1928.         $data = new ArrayCollection();
  1929.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1930.             if ($startDate <= $schoolTeacherCallSheetLine->getCreateDate() && $schoolTeacherCallSheetLine->getCreateDate() <= $endDate) {
  1931.                 $data->add($schoolTeacherCallSheetLine);
  1932.             }
  1933.         }
  1935.         return $data;
  1936.     }
  1938.     /**
  1939.      * @return Collection|AccountingChequeTrackingLine[]
  1940.      */
  1941.     public function getAccountingChequeTrackingLines(): Collection
  1942.     {
  1943.         return $this->accountingChequeTrackingLines;
  1944.     }
  1946.     public function addAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1947.     {
  1948.         if (!$this->accountingChequeTrackingLines->contains($accountingChequeTrackingLine)) {
  1949.             $this->accountingChequeTrackingLines[] = $accountingChequeTrackingLine;
  1950.             $accountingChequeTrackingLine->setRegistrationStudentRegistration($this);
  1951.         }
  1953.         return $this;
  1954.     }
  1956.     public function removeAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1957.     {
  1958.         if ($this->accountingChequeTrackingLines->removeElement($accountingChequeTrackingLine)) {
  1959.             // set the owning side to null (unless already changed)
  1960.             if ($accountingChequeTrackingLine->getRegistrationStudentRegistration() === $this) {
  1961.                 $accountingChequeTrackingLine->setRegistrationStudentRegistration(null);
  1962.             }
  1963.         }
  1965.         return $this;
  1966.     }
  1968.     public function getAbsenceStatus($day){
  1969.         $nb = 0;
  1970.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1971.             //if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getSchoolTeacherCallSheet()->getSettingTimeTable() == $settingTimeTable) {
  1972.             if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getIsAbsent()) {
  1973.                 $nb++;
  1974.             }
  1975.         }
  1977.         return $nb;
  1978.     }
  1980.     /**
  1981.      * @return Collection|SchoolReportCardAbsence[]
  1982.      */
  1983.     public function getSchoolReportCardAbsences(): Collection
  1984.     {
  1985.         return $this->schoolReportCardAbsences;
  1986.     }
  1988.     public function addSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1989.     {
  1990.         if (!$this->schoolReportCardAbsences->contains($schoolReportCardAbsence)) {
  1991.             $this->schoolReportCardAbsences[] = $schoolReportCardAbsence;
  1992.             $schoolReportCardAbsence->setStudentRegistration($this);
  1993.         }
  1995.         return $this;
  1996.     }
  1998.     public function removeSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1999.     {
  2000.         if ($this->schoolReportCardAbsences->removeElement($schoolReportCardAbsence)) {
  2001.             // set the owning side to null (unless already changed)
  2002.             if ($schoolReportCardAbsence->getStudentRegistration() === $this) {
  2003.                 $schoolReportCardAbsence->setStudentRegistration(null);
  2004.             }
  2005.         }
  2007.         return $this;
  2008.     }
  2010.     /**
  2011.      * @return Collection|WavePayment[]
  2012.      */
  2013.     public function getWavePayments(): Collection
  2014.     {
  2015.         return $this->wavePayments;
  2016.     }
  2018.     public function addWavePayment(WavePayment $wavePayment): self
  2019.     {
  2020.         if (!$this->wavePayments->contains($wavePayment)) {
  2021.             $this->wavePayments[] = $wavePayment;
  2022.             $wavePayment->setStudentRegistration($this);
  2023.         }
  2025.         return $this;
  2026.     }
  2028.     public function removeWavePayment(WavePayment $wavePayment): self
  2029.     {
  2030.         if ($this->wavePayments->removeElement($wavePayment)) {
  2031.             // set the owning side to null (unless already changed)
  2032.             if ($wavePayment->getStudentRegistration() === $this) {
  2033.                 $wavePayment->setStudentRegistration(null);
  2034.             }
  2035.         }
  2037.         return $this;
  2038.     }
  2040.     public function getSchoolAverage(SchoolAverage $schoolAverage){
  2041.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2042.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2043.                 if ($schoolStudentAverage->getNote() >= 999 || $schoolStudentAverage->getIsUnclassified()) {
  2044.                     return false;
  2045.                 }
  2047.                 return $schoolStudentAverage->getNote();
  2048.             }
  2049.         }
  2051.         return false;
  2052.     }
  2054.    
  2056.     public function getSchoolAverageSub(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2057.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2058.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2059.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2060.                     if ($schoolStudentAverage->getNote() >= 999 || $schoolStudentAverage->getIsUnclassified()) {
  2061.                         return false;
  2062.                     }
  2063.                     return $schoolStudentAverage->getNote();
  2064.                 }
  2065.             }
  2066.         }
  2068.         return false;
  2069.     }
  2071.     public function getSchoolAverageSubCoeff(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2072.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2073.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2074.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2075.                     if ($schoolStudentAverage->getNote() >= 999 || $schoolStudentAverage->getIsUnclassified()) {
  2076.                         return false;
  2077.                     }
  2078.                     return $schoolStudentAverage->getCoefficient() * ($schoolStudentAverage->getNoteOn() / $schoolSubMatter->getNotedOn());
  2079.                 }
  2080.             }
  2081.         }
  2083.         return false;
  2084.     }
  2086.     public function getSchoolAverageMaterLabel(SchoolAverage $schoolAverage){
  2087.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2088.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2089.                 if ($schoolStudentAverage->getSubMatter()) {
  2090.                     return $schoolStudentAverage->getSubMatter()->getCode();
  2091.                 }
  2092.                 
  2093.             }
  2094.         }
  2096.         return false;
  2097.     }
  2099.     public function getSchoolAverageCoeff(SchoolAverage $schoolAverage){
  2100.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2101.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2102.                 return $schoolStudentAverage->getCoefficient();
  2103.             }
  2104.         }
  2106.         return false;
  2107.     }
  2109.     public function getSchoolSubAverageCoeff(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2110.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2111.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2112.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2113.                     return $schoolStudentAverage->getCoefficient();
  2114.                 }
  2115.             }
  2116.         }
  2118.         return false;
  2119.     }
  2121.     public function average_report_card(SchoolYearPeriode $schoolYearPeriode, SchoolMatter $schoolMatter){
  2122.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2123.             if ($schoolAverageReportCard->getMatter() == $schoolMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2124.                 return $schoolAverageReportCard;
  2125.             }
  2126.         }
  2128.         return new SchoolAverageReportCard();
  2129.     }
  2131.     public function average_report_card_sub(SchoolYearPeriode $schoolYearPeriode, SchoolSubMatter $schoolSubMatter){
  2132.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2133.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2134.                 return $schoolAverageReportCard;
  2135.             }
  2136.         }
  2138.         return new SchoolAverageReportCard();
  2139.     }
  2141.     public function annual_average_report_card(SchoolMatter $schoolMatter){
  2142.         $averageReportCard = new SchoolAverageReportCard();
  2143.         
  2144.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2145.             if ($schoolAverageReportCard->getMatter() == $schoolMatter) {
  2146.                 $averageReportCard = $schoolAverageReportCard;
  2147.             }
  2148.         }
  2150.         return $averageReportCard;
  2151.     }
  2153.     public function annual_average_report_card_sub(SchoolSubMatter $schoolSubMatter){
  2154.         $averageReportCard = new SchoolAverageReportCard();
  2156.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2157.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2158.                 $averageReportCard = $schoolAverageReportCard;
  2159.             }
  2160.         }
  2162.         return $averageReportCard;
  2163.     }
  2165.     public function last_report_card(){
  2166.         $reportCard = new SchoolReportCard();
  2168.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  2169.             //if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2170.                 $reportCard = $schoolReportCard;
  2171.             //}
  2172.         }
  2174.         return $reportCard;
  2175.     }
  2177.     public function average_report_card_type(SchoolYearPeriode $schoolYearPeriode, SchoolMatterType $schoolMatterType){
  2178.         $sCoeff = 0;
  2179.         $sXCoeff = 0;
  2180.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2181.             if ($schoolAverageReportCard->getMatter()->getMatterType() == $schoolMatterType && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2182.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2183.                 $sCoeff += $schoolAverageReportCard->getCoefficient();
  2184.             }
  2185.         }
  2187.         if ($sCoeff > 0) {
  2188.             return ($sXCoeff / $sCoeff);
  2189.         }
  2191.         return 0;
  2192.     }
  2194.     public function total_xaverage_report_card(SchoolYearPeriode $schoolYearPeriode){
  2195.         $sXCoeff = 0;
  2196.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2197.             if ($schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2198.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2199.             }
  2200.         }
  2202.         return $sXCoeff;
  2203.     }
  2205.     /**
  2206.      * @return Collection|RegistrationStudentContact[]
  2207.      */
  2208.     public function getRegistrationStudentContacts(): Collection
  2209.     {
  2210.         return $this->registrationStudentContacts;
  2211.     }
  2213.     public function addRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2214.     {
  2215.         if (!$this->registrationStudentContacts->contains($registrationStudentContact)) {
  2216.             $this->registrationStudentContacts[] = $registrationStudentContact;
  2217.             $registrationStudentContact->setRegistrationStudentRegistration($this);
  2218.         }
  2220.         return $this;
  2221.     }
  2223.     public function removeRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2224.     {
  2225.         if ($this->registrationStudentContacts->removeElement($registrationStudentContact)) {
  2226.             // set the owning side to null (unless already changed)
  2227.             if ($registrationStudentContact->getRegistrationStudentRegistration() === $this) {
  2228.                 $registrationStudentContact->setRegistrationStudentRegistration(null);
  2229.             }
  2230.         }
  2232.         return $this;
  2233.     }
  2235.     /**
  2236.      * @return Collection|TransportCallSheetLine[]
  2237.      */
  2238.     public function getTransportCallSheetLines(): Collection
  2239.     {
  2240.         return $this->transportCallSheetLines;
  2241.     }
  2243.     public function addTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2244.     {
  2245.         if (!$this->transportCallSheetLines->contains($transportCallSheetLine)) {
  2246.             $this->transportCallSheetLines[] = $transportCallSheetLine;
  2247.             $transportCallSheetLine->setRegistrationStudentRegistration($this);
  2248.         }
  2250.         return $this;
  2251.     }
  2253.     public function removeTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2254.     {
  2255.         if ($this->transportCallSheetLines->removeElement($transportCallSheetLine)) {
  2256.             // set the owning side to null (unless already changed)
  2257.             if ($transportCallSheetLine->getRegistrationStudentRegistration() === $this) {
  2258.                 $transportCallSheetLine->setRegistrationStudentRegistration(null);
  2259.             }
  2260.         }
  2262.         return $this;
  2263.     }
  2265.     /**
  2266.      * @return Collection|StockExitSlip[]
  2267.      */
  2268.     public function getStockExitSlips(): Collection
  2269.     {
  2270.         return $this->stockExitSlips;
  2271.     }
  2273.     public function addStockExitSlip(StockExitSlip $stockExitSlip): self
  2274.     {
  2275.         if (!$this->stockExitSlips->contains($stockExitSlip)) {
  2276.             $this->stockExitSlips[] = $stockExitSlip;
  2277.             $stockExitSlip->setRegistrationStudentRegistration($this);
  2278.         }
  2280.         return $this;
  2281.     }
  2283.     public function removeStockExitSlip(StockExitSlip $stockExitSlip): self
  2284.     {
  2285.         if ($this->stockExitSlips->removeElement($stockExitSlip)) {
  2286.             // set the owning side to null (unless already changed)
  2287.             if ($stockExitSlip->getRegistrationStudentRegistration() === $this) {
  2288.                 $stockExitSlip->setRegistrationStudentRegistration(null);
  2289.             }
  2290.         }
  2292.         return $this;
  2293.     }
  2295.     public function getTotalSchooling(){
  2296.         $total = 0;
  2298.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2299.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2300.                 $total += $accountingStudentRegistrationFee->getAmount();
  2301.             }
  2302.         }
  2304.         return $total;
  2305.     }
  2307.     public function getSchooling(){
  2308.         $data = new ArrayCollection();
  2310.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2311.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2312.                 $data->add($accountingStudentRegistrationFee);
  2313.             }
  2314.         }
  2316.         return $data;
  2317.     }
  2319.     public function getFirstPayment(){
  2320.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  2321.             return $accountingStudentRegistrationPayment->getAmount();
  2322.         }
  2324.         return 0;
  2325.     }
  2327.     public function getIsAuthorizedAlone(): ?bool
  2328.     {
  2329.         return $this->is_authorized_alone;
  2330.     }
  2332.     public function setIsAuthorizedAlone(bool $is_authorized_alone): self
  2333.     {
  2334.         $this->is_authorized_alone = $is_authorized_alone;
  2336.         return $this;
  2337.     }
  2339.     public function getStatus(): ?string
  2340.     {
  2341.         return $this->status;
  2342.     }
  2344.     public function setStatus(string $status): self
  2345.     {
  2346.         $this->status = $status;
  2348.         return $this;
  2349.     }
  2351.     public function getQrCode(): ?string
  2352.     {
  2353.         return $this->qr_code;
  2354.     }
  2356.     public function setQrCode(?string $qr_code): self
  2357.     {
  2358.         $this->qr_code = $qr_code;
  2360.         return $this;
  2361.     }
  2363.     public function generateQrCode(): void
  2364.     {
  2365.         if ($this->qr_code === null) {
  2366.             $this->qr_code = bin2hex(random_bytes(16));
  2367.         }
  2368.     }
  2370.     public function isInscrit(): bool
  2371.     {
  2372.         return $this->status === self::STATUS_INSCRIT || $this->status === '';
  2373.     }
  2375.     public function isAbandonne(): bool
  2376.     {
  2377.         return $this->status === self::STATUS_ABANDONNE;
  2378.     }
  2380.     public function getSchoolAuthorizedPickups(): Collection
  2381.     {
  2382.         return $this->schoolAuthorizedPickups;
  2383.     }
  2385.     public function addSchoolAuthorizedPickup(SchoolAuthorizedPickup $pickup): self
  2386.     {
  2387.         if (!$this->schoolAuthorizedPickups->contains($pickup)) {
  2388.             $this->schoolAuthorizedPickups[] = $pickup;
  2389.             $pickup->setStudentRegistration($this);
  2390.         }
  2391.         return $this;
  2392.     }
  2394.     public function removeSchoolAuthorizedPickup(SchoolAuthorizedPickup $pickup): self
  2395.     {
  2396.         if ($this->schoolAuthorizedPickups->removeElement($pickup)) {
  2397.             if ($pickup->getStudentRegistration() === $this) {
  2398.                 $pickup->setStudentRegistration(null);
  2399.             }
  2400.         }
  2401.         return $this;
  2402.     }
  2403. }