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.     /**
  25.      * @ORM\Id
  26.      * @ORM\GeneratedValue
  27.      * @ORM\Column(type="integer")
  28.      */
  29.     private $id;
  31.     /**
  32.      * @ORM\ManyToOne(targetEntity=Establishment::class, inversedBy="registrationStudentRegistrations")
  33.      * @ORM\JoinColumn(nullable=false)
  34.      */
  35.     private $establishment;
  37.     /**
  38.      * @ORM\ManyToOne(targetEntity=RegistrationStudent::class, inversedBy="registrationStudentRegistrations")
  39.      * @ORM\JoinColumn(nullable=false)
  40.      */
  41.     private $student;
  43.     /**
  44.      * @ORM\ManyToOne(targetEntity=SchoolYear::class, inversedBy="registrationStudentRegistrations")
  45.      * @ORM\JoinColumn(nullable=false)
  46.      */
  47.     private $schoolYear;
  49.     /**
  50.      * @ORM\ManyToOne(targetEntity=SettingClassroom::class, inversedBy="registrationStudentRegistrations")
  51.      * @ORM\JoinColumn(nullable=false)
  52.      */
  53.     private $classroom;
  55.     /**
  56.      * @ORM\Column(type="boolean")
  57.      */
  58.     private $is_redoubling;
  60.     /**
  61.      * @ORM\Column(type="boolean")
  62.      * est boursier
  63.      */
  64.     private $is_diet;
  66.     /**
  67.      * @ORM\Column(type="boolean")
  68.      * est interne
  69.      */
  70.     private $is_internal;
  72.     /**
  73.      * @ORM\Column(type="boolean")
  74.      * est affecte(e)
  75.     */
  76.     private $is_affected;
  78.     /**
  79.      * @ORM\Column(type="date_immutable")
  80.     */
  81.     private $registered_at;
  83.     /**
  84.      * @ORM\Column(type="datetime_immutable")
  85.     */
  86.     private $created_at;
  88.     /**
  89.      * @ORM\Column(type="datetime_immutable")
  90.      */
  91.     private $updated_at;
  93.     /**
  94.      * @ORM\Column(type="integer")
  95.      */
  96.     private $created_by;
  98.     /**
  99.      * @ORM\Column(type="integer")
  100.      */
  101.     private $updated_by;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationFee::class, mappedBy="studentRegistration")
  105.      */
  106.     private $accountingStudentRegistrationFees;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=SchoolReportCard::class, mappedBy="studentRegistration")
  110.      * @ORM\OrderBy({"id" = "ASC"})
  111.      */
  112.     private $schoolReportCards;
  114.     /**
  115.      * @ORM\OneToMany(targetEntity=SchoolAverageReportCard::class, mappedBy="studentRegistration")
  116.      */
  117.     private $schoolAverageReportCards;
  119.     /**
  120.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClass::class, mappedBy="studentRegistration")
  121.      */
  122.     private $schoolAssessmentByClasses;
  124.     /**
  125.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevel::class, mappedBy="studentRegistration")
  126.      */
  127.     private $schoolAssessmentByLevels;
  129.     /**
  130.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClassByMatter::class, mappedBy="studentRegistration")
  131.      */
  132.     private $schoolAssessmentByClassByMatters;
  134.     /**
  135.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevelByMatter::class, mappedBy="studentRegistration")
  136.      */
  137.     private $schoolAssessmentByLevelByMatters;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationPayment::class, mappedBy="studentRegistration")
  141.      */
  142.     private $accountingStudentRegistrationPayments;
  144.     /**
  145.      * @ORM\Column(type="float", nullable=true)
  146.     */
  147.     private $last_amount_paid;
  149.     /**
  150.      * @ORM\Column(type="integer", nullable=true)
  151.     */
  152.     private $last_payment_id;
  154.     /**
  155.      * @ORM\Column(type="datetime_immutable", nullable=true)
  156.     */
  157.     private $last_payment_at;
  159.     /**
  160.      * @ORM\Column(type="string", length=255, nullable=true)
  161.      */
  162.     private $image;
  164.     /**
  165.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  166.      * 
  167.      * @Vich\UploadableField(mapping="student", fileNameProperty="image")
  168.      * 
  169.      * @var File|null
  170.      * @Assert\File(
  171.      * maxSize = "25M",
  172.      * mimeTypes = {"image/png", "image/jpg", "image/jpeg"},
  173.      * mimeTypesMessage = "Veuillez télécharger une image valide (png, jpg, jpeg)",
  174.      * maxSizeMessage = "Le fichier est trop volumineux ({{size}} {{suffix}}). La taille maximale autorisée est {{limit}} {{suffix}}"
  175.      * )
  176.      */
  177.     private $imageFile;
  179.     /**
  180.      * @ORM\OneToMany(targetEntity=RegistrationClassChange::class, mappedBy="studentRegistration")
  181.      */
  182.     private $registrationClassChanges;
  184.     /**
  185.      * @ORM\OneToMany(targetEntity=RegistrationStudentDowngrade::class, mappedBy="registrationStudentRegistration")
  186.      */
  187.     private $registrationStudentDowngrades;
  189.     /**
  190.      * @ORM\OneToMany(targetEntity=RegistrationStudentAbandonment::class, mappedBy="registrationStudentRegistration")
  191.      */
  192.     private $registrationStudentAbandonments;
  194.     /**
  195.      * @ORM\Column(type="boolean")
  196.     */
  197.     private $is_abandonned;
  199.     /**
  200.      * @ORM\ManyToOne(targetEntity=RegistrationStudentPreRegistration::class, inversedBy="registrationStudentRegistrations")
  201.      */
  202.     private $registrationStudentPreRegistration;
  204.     /**
  205.      * @ORM\OneToMany(targetEntity=RegistrationTransportCheckpoint::class, mappedBy="registrationStudentRegistration")
  206.      */
  207.     private $registrationTransportCheckpoints;
  209.     /**
  210.      * @ORM\Column(type="boolean")
  211.      */
  212.     private $as_food_restrictions;
  214.     /**
  215.      * @ORM\Column(type="boolean")
  216.      */
  217.     private $is_meatless_menu;
  219.     /**
  220.      * @ORM\Column(type="boolean")
  221.      */
  222.     private $is_menu_without_pork;
  224.     /**
  225.      * @ORM\Column(type="boolean")
  226.      */
  227.     private $is_can_eat_alone;
  229.     /**
  230.      * @ORM\Column(type="boolean")
  231.      */
  232.     private $is_can_do_his_business_alone;
  234.     /**
  235.      * @ORM\Column(type="boolean")
  236.      */
  237.     private $is_falls_sleep_easily;
  239.     /**
  240.      * @ORM\OneToMany(targetEntity=SchoolAbsenceAndDelay::class, mappedBy="studentRegistration")
  241.      */
  242.     private $schoolAbsenceAndDelays;
  244.     /**
  245.      * @ORM\ManyToMany(targetEntity=SettingDocumentToProvide::class, inversedBy="registrationStudentRegistrations")
  246.      */
  247.     private $documentProvides;
  249.     /**
  250.      * @ORM\ManyToMany(targetEntity=CommunicationMessage::class, mappedBy="studentRegistrations")
  251.      */
  252.     private $communicationMessages;
  254.     /**
  255.      * @ORM\Column(type="boolean")
  256.     */
  257.     private $is_new;
  259.     /**
  260.      * @ORM\OneToMany(targetEntity=StockStudentKitEntry::class, mappedBy="registrationStudent")
  261.      */
  262.     private $stockStudentKitEntries;
  264.     /**
  265.      * @ORM\OneToMany(targetEntity=StockKitOut::class, mappedBy="registrationStudent")
  266.      */
  267.     private $stockKitOuts;
  269.     /**
  270.      * @ORM\Column(type="string", length=60, nullable=true)
  271.      */
  272.     private $portal_login;
  274.     /**
  275.      * @ORM\Column(type="string", length=60, nullable=true)
  276.      */
  277.     private $portal_password;
  279.     /**
  280.      * @ORM\OneToMany(targetEntity=AccountingCredit::class, mappedBy="studentRegistration")
  281.      */
  282.     private $accountingCredits;
  284.     /**
  285.      * @ORM\OneToMany(targetEntity=SchoolStudentAverage::class, mappedBy="registrationStudentRegistration")
  286.      */
  287.     private $schoolStudentAverages;
  289.     /**
  290.      * @ORM\OneToMany(targetEntity=NurseryTimeSheet::class, mappedBy="registrationStudentRegistration")
  291.      */
  292.     private $nurseryTimeSheets;
  294.     /**
  295.      * @ORM\OneToMany(targetEntity=SchoolTeacherCallSheetLine::class, mappedBy="registrationStudentRegistration")
  296.      */
  297.     private $schoolTeacherCallSheetLines;
  299.     /**
  300.      * @ORM\OneToMany(targetEntity=AccountingChequeTrackingLine::class, mappedBy="registrationStudentRegistration")
  301.      */
  302.     private $accountingChequeTrackingLines;
  304.     /**
  305.      * @ORM\OneToMany(targetEntity=SchoolReportCardAbsence::class, mappedBy="studentRegistration")
  306.      */
  307.     private $schoolReportCardAbsences;
  309.     /**
  310.      * @ORM\OneToMany(targetEntity=WavePayment::class, mappedBy="studentRegistration")
  311.      */
  312.     private $wavePayments;
  314.     /**
  315.      * @ORM\OneToMany(targetEntity=RegistrationStudentContact::class, mappedBy="registrationStudentRegistration")
  316.      */
  317.     private $registrationStudentContacts;
  319.     /**
  320.      * @ORM\OneToMany(targetEntity=TransportCallSheetLine::class, mappedBy="registrationStudentRegistration")
  321.      */
  322.     private $transportCallSheetLines;
  324.     /**
  325.      * @ORM\OneToMany(targetEntity=StockExitSlip::class, mappedBy="registrationStudentRegistration")
  326.      */
  327.     private $stockExitSlips;
  329.     /**
  330.      * @ORM\Column(type="boolean")
  331.      */
  332.     private $is_authorized_alone;
  334.     public function __construct()
  335.     {
  336.         $this->accountingStudentRegistrationFees = new ArrayCollection();
  337.         $this->schoolReportCards = new ArrayCollection();
  338.         $this->schoolAverageReportCards = new ArrayCollection();
  339.         $this->schoolAssessmentByClasses = new ArrayCollection();
  340.         $this->schoolAssessmentByLevels = new ArrayCollection();
  341.         $this->schoolAssessmentByClassByMatters = new ArrayCollection();
  342.         $this->schoolAssessmentByLevelByMatters = new ArrayCollection();
  343.         $this->is_affected = false;
  344.         $this->is_diet = false;
  345.         $this->is_internal = true;
  346.         $this->is_redoubling = false;
  347.         $this->is_abandonned = false;
  348.         $this->registered_at = new DateTimeImmutable();
  349.         $this->accountingStudentRegistrationPayments = new ArrayCollection();
  350.         $this->registrationClassChanges = new ArrayCollection();
  351.         $this->registrationStudentDowngrades = new ArrayCollection();
  352.         $this->registrationStudentAbandonments = new ArrayCollection();
  353.         $this->registrationTransportCheckpoints = new ArrayCollection();
  355.         $this->as_food_restrictions = false;
  356.         $this->is_meatless_menu = false;
  357.         $this->is_menu_without_pork = false;
  358.         $this->is_can_eat_alone = true;
  359.         $this->is_can_do_his_business_alone = true;
  360.         $this->is_falls_sleep_easily = false;
  361.         $this->schoolAbsenceAndDelays = new ArrayCollection();
  362.         $this->documentProvides = new ArrayCollection();
  363.         $this->communicationMessages = new ArrayCollection();
  365.         $this->is_new = false;
  366.         $this->is_authorized_alone = false;
  367.         $this->stockStudentKitEntries = new ArrayCollection();
  368.         $this->stockKitOuts = new ArrayCollection();
  369.         $this->accountingCredits = new ArrayCollection();
  370.         $this->schoolStudentAverages = new ArrayCollection();
  371.         $this->nurseryTimeSheets = new ArrayCollection();
  372.         $this->schoolTeacherCallSheetLines = new ArrayCollection();
  373.         $this->accountingChequeTrackingLines = new ArrayCollection();
  374.         $this->schoolReportCardAbsences = new ArrayCollection();
  375.         $this->wavePayments = new ArrayCollection();
  376.         $this->registrationStudentContacts = new ArrayCollection();
  377.         $this->transportCallSheetLines = new ArrayCollection();
  378.         $this->stockExitSlips = new ArrayCollection();
  379.     }
  381.     public function getName()
  382.     {
  383.         return $this->getStudent()->getName();
  384.     }
  386.     public function __toString()
  387.     {
  388.         return $this->getName().' ['.$this->getClassroom()->getLabel().']'.' ['.$this->getStudent()->getRegistrationNumber().']';
  389.     }
  391.     /**
  392.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  393.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  394.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  395.      * must be able to accept an instance of 'File' as the bundle will inject one here
  396.      * during Doctrine hydration.
  397.      *
  398.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  399.      */
  400.     public function setImageFile(?File $imageFile = null): void
  401.     {
  402.         $this->imageFile = $imageFile;
  404.         if (null !== $imageFile) {
  405.             // It is required that at least one field changes if you are using doctrine
  406.             // otherwise the event listeners won't be called and the file is lost
  407.             $this->updated_at = new \DateTimeImmutable();
  408.         }
  409.     }
  411.     public function getImageFile(): ?File
  412.     {
  413.         return $this->imageFile;
  414.     }
  416.     public function getId(): ?int
  417.     {
  418.         return $this->id;
  419.     }
  421.     public function getEstablishment(): ?Establishment
  422.     {
  423.         return $this->establishment;
  424.     }
  426.     public function setEstablishment(?Establishment $establishment): self
  427.     {
  428.         $this->establishment = $establishment;
  430.         return $this;
  431.     }
  433.     public function getStudent(): ?RegistrationStudent
  434.     {
  435.         return $this->student;
  436.     }
  438.     public function setStudent(?RegistrationStudent $student): self
  439.     {
  440.         $this->student = $student;
  442.         return $this;
  443.     }
  445.     public function getSchoolYear(): ?SchoolYear
  446.     {
  447.         return $this->schoolYear;
  448.     }
  450.     public function setSchoolYear(?SchoolYear $schoolYear): self
  451.     {
  452.         $this->schoolYear = $schoolYear;
  454.         return $this;
  455.     }
  457.     public function getClassroom(): ?SettingClassroom
  458.     {
  459.         return $this->classroom;
  460.     }
  462.     public function setClassroom(?SettingClassroom $classroom): self
  463.     {
  464.         $this->classroom = $classroom;
  466.         return $this;
  467.     }
  469.     public function getCreatedAt(): ?\DateTimeImmutable
  470.     {
  471.         return $this->created_at;
  472.     }
  474.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  475.     {
  476.         $this->created_at = $created_at;
  478.         return $this;
  479.     }
  481.     public function getUpdatedAt(): ?\DateTimeImmutable
  482.     {
  483.         return $this->updated_at;
  484.     }
  486.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  487.     {
  488.         $this->updated_at = $updated_at;
  490.         return $this;
  491.     }
  493.     public function getCreatedBy(): ?int
  494.     {
  495.         return $this->created_by;
  496.     }
  498.     public function setCreatedBy(int $created_by): self
  499.     {
  500.         $this->created_by = $created_by;
  502.         return $this;
  503.     }
  505.     public function getUpdatedBy(): ?int
  506.     {
  507.         return $this->updated_by;
  508.     }
  510.     public function setUpdatedBy(int $updated_by): self
  511.     {
  512.         $this->updated_by = $updated_by;
  514.         return $this;
  515.     }
  517.     /**
  518.      * @return Collection|AccountingStudentRegistrationFee[]
  519.      */
  520.     public function getAccountingStudentRegistrationFees(): Collection
  521.     {
  522.         return $this->accountingStudentRegistrationFees;
  523.     }
  525.     public function addAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  526.     {
  527.         if (!$this->accountingStudentRegistrationFees->contains($accountingStudentRegistrationFee)) {
  528.             $this->accountingStudentRegistrationFees[] = $accountingStudentRegistrationFee;
  529.             $accountingStudentRegistrationFee->setStudentRegistration($this);
  530.         }
  532.         return $this;
  533.     }
  535.     public function removeAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  536.     {
  537.         if ($this->accountingStudentRegistrationFees->removeElement($accountingStudentRegistrationFee)) {
  538.             // set the owning side to null (unless already changed)
  539.             if ($accountingStudentRegistrationFee->getStudentRegistration() === $this) {
  540.                 $accountingStudentRegistrationFee->setStudentRegistration(null);
  541.             }
  542.         }
  544.         return $this;
  545.     }
  547.     /**
  548.      * @return Collection|SchoolReportCard[]
  549.      */
  550.     public function getSchoolReportCards(): Collection
  551.     {
  552.         return $this->schoolReportCards;
  553.     }
  555.     public function addSchoolReportCard(SchoolReportCard $schoolReportCard): self
  556.     {
  557.         if (!$this->schoolReportCards->contains($schoolReportCard)) {
  558.             $this->schoolReportCards[] = $schoolReportCard;
  559.             $schoolReportCard->setStudentRegistration($this);
  560.         }
  562.         return $this;
  563.     }
  565.    
  566.     public function getOrderedSchoolReportCards(SchoolReportCardRepository $schoolReportCardRepository)
  567.     {
  568.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  569.         ->innerJoin('entity.schoolYearPeriode', 'schoolYearPeriode')
  570.         ->addSelect('schoolYearPeriode')
  572.         ->andWhere('entity.studentRegistration = :studentRegistration')
  573.         ->setParameter('studentRegistration', $this)
  575.         ->orderBy('schoolYearPeriode.code', 'ASC')
  576.         ->getQuery()
  577.         ->getResult();
  579.         return $schoolReportCards;
  580.     }
  582.     public function removeSchoolReportCard(SchoolReportCard $schoolReportCard): self
  583.     {
  584.         if ($this->schoolReportCards->removeElement($schoolReportCard)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($schoolReportCard->getStudentRegistration() === $this) {
  587.                 $schoolReportCard->setStudentRegistration(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection|SchoolAverageReportCard[]
  596.      */
  597.     public function getSchoolAverageReportCards(): Collection
  598.     {
  599.         return $this->schoolAverageReportCards;
  600.     }
  602.     public function addSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  603.     {
  604.         if (!$this->schoolAverageReportCards->contains($schoolAverageReportCard)) {
  605.             $this->schoolAverageReportCards[] = $schoolAverageReportCard;
  606.             $schoolAverageReportCard->setStudentRegistration($this);
  607.         }
  609.         return $this;
  610.     }
  612.     public function removeSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  613.     {
  614.         if ($this->schoolAverageReportCards->removeElement($schoolAverageReportCard)) {
  615.             // set the owning side to null (unless already changed)
  616.             if ($schoolAverageReportCard->getStudentRegistration() === $this) {
  617.                 $schoolAverageReportCard->setStudentRegistration(null);
  618.             }
  619.         }
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return Collection|SchoolAssessmentByClass[]
  626.      */
  627.     public function getSchoolAssessmentByClasses(): Collection
  628.     {
  629.         return $this->schoolAssessmentByClasses;
  630.     }
  632.     public function addSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  633.     {
  634.         if (!$this->schoolAssessmentByClasses->contains($schoolAssessmentByClass)) {
  635.             $this->schoolAssessmentByClasses[] = $schoolAssessmentByClass;
  636.             $schoolAssessmentByClass->setStudentRegistration($this);
  637.         }
  639.         return $this;
  640.     }
  642.     public function removeSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  643.     {
  644.         if ($this->schoolAssessmentByClasses->removeElement($schoolAssessmentByClass)) {
  645.             // set the owning side to null (unless already changed)
  646.             if ($schoolAssessmentByClass->getStudentRegistration() === $this) {
  647.                 $schoolAssessmentByClass->setStudentRegistration(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * @return Collection|SchoolAssessmentByLevel[]
  656.      */
  657.     public function getSchoolAssessmentByLevels(): Collection
  658.     {
  659.         return $this->schoolAssessmentByLevels;
  660.     }
  662.     public function addSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  663.     {
  664.         if (!$this->schoolAssessmentByLevels->contains($schoolAssessmentByLevel)) {
  665.             $this->schoolAssessmentByLevels[] = $schoolAssessmentByLevel;
  666.             $schoolAssessmentByLevel->setStudentRegistration($this);
  667.         }
  669.         return $this;
  670.     }
  672.     public function removeSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  673.     {
  674.         if ($this->schoolAssessmentByLevels->removeElement($schoolAssessmentByLevel)) {
  675.             // set the owning side to null (unless already changed)
  676.             if ($schoolAssessmentByLevel->getStudentRegistration() === $this) {
  677.                 $schoolAssessmentByLevel->setStudentRegistration(null);
  678.             }
  679.         }
  681.         return $this;
  682.     }
  684.     /**
  685.      * @return Collection|SchoolAssessmentByClassByMatter[]
  686.      */
  687.     public function getSchoolAssessmentByClassByMatters(): Collection
  688.     {
  689.         return $this->schoolAssessmentByClassByMatters;
  690.     }
  692.     public function addSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  693.     {
  694.         if (!$this->schoolAssessmentByClassByMatters->contains($schoolAssessmentByClassByMatter)) {
  695.             $this->schoolAssessmentByClassByMatters[] = $schoolAssessmentByClassByMatter;
  696.             $schoolAssessmentByClassByMatter->setStudentRegistration($this);
  697.         }
  699.         return $this;
  700.     }
  702.     public function removeSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  703.     {
  704.         if ($this->schoolAssessmentByClassByMatters->removeElement($schoolAssessmentByClassByMatter)) {
  705.             // set the owning side to null (unless already changed)
  706.             if ($schoolAssessmentByClassByMatter->getStudentRegistration() === $this) {
  707.                 $schoolAssessmentByClassByMatter->setStudentRegistration(null);
  708.             }
  709.         }
  711.         return $this;
  712.     }
  714.     /**
  715.      * @return Collection|SchoolAssessmentByLevelByMatter[]
  716.      */
  717.     public function getSchoolAssessmentByLevelByMatters(): Collection
  718.     {
  719.         return $this->schoolAssessmentByLevelByMatters;
  720.     }
  722.     public function addSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  723.     {
  724.         if (!$this->schoolAssessmentByLevelByMatters->contains($schoolAssessmentByLevelByMatter)) {
  725.             $this->schoolAssessmentByLevelByMatters[] = $schoolAssessmentByLevelByMatter;
  726.             $schoolAssessmentByLevelByMatter->setStudentRegistration($this);
  727.         }
  729.         return $this;
  730.     }
  732.     public function removeSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  733.     {
  734.         if ($this->schoolAssessmentByLevelByMatters->removeElement($schoolAssessmentByLevelByMatter)) {
  735.             // set the owning side to null (unless already changed)
  736.             if ($schoolAssessmentByLevelByMatter->getStudentRegistration() === $this) {
  737.                 $schoolAssessmentByLevelByMatter->setStudentRegistration(null);
  738.             }
  739.         }
  741.         return $this;
  742.     }
  744.     public function getIsRedoubling(): ?bool
  745.     {
  746.         return $this->is_redoubling;
  747.     }
  749.     public function setIsRedoubling(bool $is_redoubling): self
  750.     {
  751.         $this->is_redoubling = $is_redoubling;
  753.         return $this;
  754.     }
  756.     public function getIsDiet(): ?bool
  757.     {
  758.         return $this->is_diet;
  759.     }
  761.     public function setIsDiet(bool $is_diet): self
  762.     {
  763.         $this->is_diet = $is_diet;
  765.         return $this;
  766.     }
  768.     public function getIsInternal(): ?bool
  769.     {
  770.         return $this->is_internal;
  771.     }
  773.     public function setIsInternal(bool $is_internal): self
  774.     {
  775.         $this->is_internal = $is_internal;
  777.         return $this;
  778.     }
  780.     public function getIsAffected(): ?bool
  781.     {
  782.         return $this->is_affected;
  783.     }
  785.     public function setIsAffected(bool $is_affected): self
  786.     {
  787.         $this->is_affected = $is_affected;
  789.         return $this;
  790.     }
  792.     public function getRegisteredAt(): ?\DateTimeImmutable
  793.     {
  794.         return $this->registered_at;
  795.     }
  797.     public function setRegisteredAt(\DateTimeImmutable $registered_at): self
  798.     {
  799.         $this->registered_at = $registered_at;
  801.         return $this;
  802.     }
  804.     public function getGleAmount(){
  805.         $amount = 0;
  806.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $fee) {
  807.             if (!$fee->getIsArchived()) {
  808.                 $amount = $amount + $fee->getAmount();
  809.             }
  810.         }
  812.         return $amount;
  813.     }
  815.     public function getAmountPaid(){
  816.         $amount = 0;
  817.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  818.             //if (!$accountingStudentRegistrationPayment->isCanBeShow()) {
  819.                 $amount = $amount + $accountingStudentRegistrationPayment->getAmount();
  820.             //}
  821.         }
  823.         $payArchived = 0;
  824.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  825.             if ($accountingStudentRegistrationFee->getIsArchived()) {
  826.                 $payArchived = $payArchived + $accountingStudentRegistrationFee->getAmountPaid();
  827.             }
  828.             
  829.         }
  832.         return $amount - $payArchived;
  833.     }
  835.     public function getAmountCancel(): ?float
  836.     {
  837.         $amountCancel = 0;
  838.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  839.             //if (!$accountingStudentRegistrationFee->getIsArchived()) {
  840.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountReported();
  841.             //}
  842.         }
  843.         
  844.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  845.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  846.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountCancel();
  847.             }
  848.         }
  849.         
  850.         return $amountCancel;
  851.     }
  853.     public function getAmountRest(): ?float
  854.     {
  855.         $amount = ($this->getGleAmount() - ($this->getAmountPaid() + $this->getAmountCancel()));
  856.         return $amount > 0 ? $amount : 0;
  857.     }
  859.     /**
  860.      * @return Collection|AccountingStudentRegistrationPayment[]
  861.      */
  862.     public function getAccountingStudentRegistrationPayments(): Collection
  863.     {
  864.         return $this->accountingStudentRegistrationPayments;
  865.     }
  867.     public function addAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  868.     {
  869.         if (!$this->accountingStudentRegistrationPayments->contains($accountingStudentRegistrationPayment)) {
  870.             $this->accountingStudentRegistrationPayments[] = $accountingStudentRegistrationPayment;
  871.             $accountingStudentRegistrationPayment->setStudentRegistration($this);
  872.         }
  874.         return $this;
  875.     }
  877.     public function removeAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  878.     {
  879.         if ($this->accountingStudentRegistrationPayments->removeElement($accountingStudentRegistrationPayment)) {
  880.             // set the owning side to null (unless already changed)
  881.             if ($accountingStudentRegistrationPayment->getStudentRegistration() === $this) {
  882.                 $accountingStudentRegistrationPayment->setStudentRegistration(null);
  883.             }
  884.         }
  886.         return $this;
  887.     }
  889.     public function getLastAmountPaid(): ?float
  890.     {
  891.         return $this->last_amount_paid;
  892.     }
  894.     public function setLastAmountPaid(?float $last_amount_paid): self
  895.     {
  896.         $this->last_amount_paid = $last_amount_paid;
  898.         return $this;
  899.     }
  901.     public function getLastPaymentId(): ?int
  902.     {
  903.         return $this->last_payment_id;
  904.     }
  906.     public function setLastPaymentId(?int $last_payment_id): self
  907.     {
  908.         $this->last_payment_id = $last_payment_id;
  910.         return $this;
  911.     }
  913.     public function getLastPaymentAt(): ?\DateTimeImmutable
  914.     {
  915.         return $this->last_payment_at;
  916.     }
  918.     public function setLastPaymentAt(?\DateTimeImmutable $last_payment_at): self
  919.     {
  920.         $this->last_payment_at = $last_payment_at;
  922.         return $this;
  923.     }
  925.     public function getImage(): ?string
  926.     {
  927.         return $this->image;
  928.     }
  930.     public function setImage(?string $image): self
  931.     {
  932.         $this->image = $image;
  934.         return $this;
  935.     }
  937.     /**
  938.      * @return Collection|RegistrationClassChange[]
  939.      */
  940.     public function getRegistrationClassChanges(): Collection
  941.     {
  942.         return $this->registrationClassChanges;
  943.     }
  945.     public function addRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  946.     {
  947.         if (!$this->registrationClassChanges->contains($registrationClassChange)) {
  948.             $this->registrationClassChanges[] = $registrationClassChange;
  949.             $registrationClassChange->setStudentRegistration($this);
  950.         }
  952.         return $this;
  953.     }
  955.     public function removeRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  956.     {
  957.         if ($this->registrationClassChanges->removeElement($registrationClassChange)) {
  958.             // set the owning side to null (unless already changed)
  959.             if ($registrationClassChange->getStudentRegistration() === $this) {
  960.                 $registrationClassChange->setStudentRegistration(null);
  961.             }
  962.         }
  964.         return $this;
  965.     }
  967.     /**
  968.      * @return Collection|RegistrationStudentDowngrade[]
  969.      */
  970.     public function getRegistrationStudentDowngrades(): Collection
  971.     {
  972.         return $this->registrationStudentDowngrades;
  973.     }
  975.     public function addRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  976.     {
  977.         if (!$this->registrationStudentDowngrades->contains($registrationStudentDowngrade)) {
  978.             $this->registrationStudentDowngrades[] = $registrationStudentDowngrade;
  979.             $registrationStudentDowngrade->setRegistrationStudentRegistration($this);
  980.         }
  982.         return $this;
  983.     }
  985.     public function removeRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  986.     {
  987.         if ($this->registrationStudentDowngrades->removeElement($registrationStudentDowngrade)) {
  988.             // set the owning side to null (unless already changed)
  989.             if ($registrationStudentDowngrade->getRegistrationStudentRegistration() === $this) {
  990.                 $registrationStudentDowngrade->setRegistrationStudentRegistration(null);
  991.             }
  992.         }
  994.         return $this;
  995.     }
  997.     /**
  998.      * @return Collection|RegistrationStudentAbandonment[]
  999.      */
  1000.     public function getRegistrationStudentAbandonments(): Collection
  1001.     {
  1002.         return $this->registrationStudentAbandonments;
  1003.     }
  1005.     public function addRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1006.     {
  1007.         if (!$this->registrationStudentAbandonments->contains($registrationStudentAbandonment)) {
  1008.             $this->registrationStudentAbandonments[] = $registrationStudentAbandonment;
  1009.             $registrationStudentAbandonment->setRegistrationStudentRegistration($this);
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function removeRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1016.     {
  1017.         if ($this->registrationStudentAbandonments->removeElement($registrationStudentAbandonment)) {
  1018.             // set the owning side to null (unless already changed)
  1019.             if ($registrationStudentAbandonment->getRegistrationStudentRegistration() === $this) {
  1020.                 $registrationStudentAbandonment->setRegistrationStudentRegistration(null);
  1021.             }
  1022.         }
  1024.         return $this;
  1025.     }
  1027.     public function getIsAbandonned(): ?bool
  1028.     {
  1029.         return $this->is_abandonned;
  1030.     }
  1032.     public function setIsAbandonned(bool $is_abandonned): self
  1033.     {
  1034.         $this->is_abandonned = $is_abandonned;
  1036.         return $this;
  1037.     }
  1039.     public function getRegistrationStudentPreRegistration(): ?RegistrationStudentPreRegistration
  1040.     {
  1041.         return $this->registrationStudentPreRegistration;
  1042.     }
  1044.     public function setRegistrationStudentPreRegistration(?RegistrationStudentPreRegistration $registrationStudentPreRegistration): self
  1045.     {
  1046.         $this->registrationStudentPreRegistration = $registrationStudentPreRegistration;
  1048.         return $this;
  1049.     }
  1051.     /**
  1052.      * @return Collection|RegistrationTransportCheckpoint[]
  1053.      */
  1054.     public function getRegistrationTransportCheckpoints(): Collection
  1055.     {
  1056.         return $this->registrationTransportCheckpoints;
  1057.     }
  1059.     public function addRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1060.     {
  1061.         if (!$this->registrationTransportCheckpoints->contains($registrationTransportCheckpoint)) {
  1062.             $this->registrationTransportCheckpoints[] = $registrationTransportCheckpoint;
  1063.             $registrationTransportCheckpoint->setRegistrationStudentRegistration($this);
  1064.         }
  1066.         return $this;
  1067.     }
  1069.     public function removeRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1070.     {
  1071.         if ($this->registrationTransportCheckpoints->removeElement($registrationTransportCheckpoint)) {
  1072.             // set the owning side to null (unless already changed)
  1073.             if ($registrationTransportCheckpoint->getRegistrationStudentRegistration() === $this) {
  1074.                 $registrationTransportCheckpoint->setRegistrationStudentRegistration(null);
  1075.             }
  1076.         }
  1078.         return $this;
  1079.     }
  1081.     public function hasTransportFee(){
  1082.         $reponse = false;
  1083.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1084.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::TRANSPORT_FEE && !$accountingStudentRegistrationFee->getIsCancel() && $accountingStudentRegistrationFee->getAmountPaid() > 0 && !$accountingStudentRegistrationFee->getIsArchived()) {
  1085.                 $reponse = true;
  1086.                 break;
  1087.             }
  1088.         }
  1090.         return $reponse;
  1091.     }
  1093.     public function hasGardeMidiFee(){
  1094.         $reponse = false;
  1095.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1096.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::GARDE_MIDI_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1097.                 $reponse = true;
  1098.                 break;
  1099.             }
  1100.         }
  1102.         return $reponse;
  1103.     }
  1105.     public function hasExtraFee(){
  1106.         $reponse = false;
  1107.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1108.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::ACTIVITE_EXTAT_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1109.                 $reponse = true;
  1110.                 break;
  1111.             }
  1112.         }
  1114.         return $reponse;
  1115.     }
  1117.     public function hasCanteenFee(){
  1118.         $reponse = false;
  1119.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1120.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::CANTINE_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1121.                 $reponse = true;
  1122.                 break;
  1123.             }
  1124.         }
  1126.         return $reponse;
  1127.     }
  1129.     public function hasMobileApp(){
  1130.         $reponse = false;
  1131.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1132.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::MOBILE_APP && !$accountingStudentRegistrationFee->getIsCancel()) {
  1133.                 $reponse = true;
  1134.                 break;
  1135.             }
  1136.         }
  1138.         return $reponse;
  1139.     }
  1141.     public function getAmountDueAt(DateTimeImmutable $dueDate, $category = '0'){
  1142.         
  1143.         $amountDue = 0;
  1144.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1145.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1146.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1147.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() >= 0) {
  1148.                         if ('0' != $category) {
  1149.                             if ($accountingStudentRegistrationFee->getFee()->getCategory() == $category) {
  1150.                                 $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1151.                             }
  1152.                         }else {
  1153.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1154.                         }
  1155.                     }
  1156.                 }
  1157.             }
  1158.         }
  1160.         $amountChequeTracking = 0;
  1161.         foreach ($this->getAccountingChequeTrackingLines() as $key => $accountingChequeTrackingLine) {
  1162.             if ($accountingChequeTrackingLine->getAccountingChequeTracking()->getStatus() == AccountingChequeTracking::EN_TRAITEMENT) {
  1163.                 $amountChequeTracking += $accountingChequeTrackingLine->getAmount();
  1164.             }
  1165.         }
  1166.         
  1167.         return $amountDue - $amountChequeTracking;
  1168.     }
  1170.     public function getAmountDueAtByFee(DateTimeImmutable $dueDate, SettingFee $settingFee){
  1171.         
  1172.         $amountDue = 0;
  1173.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1174.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1175.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1176.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1177.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1178.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1179.                         }
  1180.                     }
  1181.                 }
  1182.             }
  1183.         }
  1184.         
  1185.         return $amountDue;
  1186.     }
  1188.     public function getAmountByFee(SettingFee $settingFee){
  1189.         
  1190.         $amountDue = 0;
  1191.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1192.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1193.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1194.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1195.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1196.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmount();
  1197.                         }
  1198.                     //}
  1199.                 }
  1200.             }
  1201.         }
  1202.         
  1203.         return $amountDue;
  1204.     }
  1206.     public function getAmountPaidByFee(SettingFee $settingFee){
  1207.         
  1208.         $amountDue = 0;
  1209.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1210.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1211.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1212.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1213.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1214.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountPaid();
  1215.                         }
  1216.                     //}
  1217.                 }
  1218.             }
  1219.         }
  1220.         
  1221.         return $amountDue;
  1222.     }
  1224.     public function getAmountRestByFee(SettingFee $settingFee){
  1225.         
  1226.         $amountDue = 0;
  1227.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1228.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1229.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1230.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1231.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1232.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1233.                         }
  1234.                     //}
  1235.                 }
  1236.             }
  1237.         }
  1238.         
  1239.         return $amountDue;
  1240.     }
  1242.     public function getFeeShedulDues(DateTimeImmutable $dueDate){
  1243.         $feeShedulDues = new ArrayCollection();
  1244.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1245.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1246.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1247.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1248.                         $feeShedulDues->add($accountingStudentRegistrationFeeShedul);
  1249.                     }
  1250.                 }
  1251.             }
  1252.         }
  1253.         
  1254.         return $feeShedulDues;
  1255.     }
  1257.     public function getAsFoodRestrictions(): ?bool
  1258.     {
  1259.         return $this->as_food_restrictions;
  1260.     }
  1262.     public function setAsFoodRestrictions(bool $as_food_restrictions): self
  1263.     {
  1264.         $this->as_food_restrictions = $as_food_restrictions;
  1266.         return $this;
  1267.     }
  1269.     public function getIsMeatlessMenu(): ?bool
  1270.     {
  1271.         return $this->is_meatless_menu;
  1272.     }
  1274.     public function setIsMeatlessMenu(bool $is_meatless_menu): self
  1275.     {
  1276.         $this->is_meatless_menu = $is_meatless_menu;
  1278.         return $this;
  1279.     }
  1281.     public function getIsMenuWithoutPork(): ?bool
  1282.     {
  1283.         return $this->is_menu_without_pork;
  1284.     }
  1286.     public function setIsMenuWithoutPork(bool $is_menu_without_pork): self
  1287.     {
  1288.         $this->is_menu_without_pork = $is_menu_without_pork;
  1290.         return $this;
  1291.     }
  1293.     public function getIsCanEatAlone(): ?bool
  1294.     {
  1295.         return $this->is_can_eat_alone;
  1296.     }
  1298.     public function setIsCanEatAlone(bool $is_can_eat_alone): self
  1299.     {
  1300.         $this->is_can_eat_alone = $is_can_eat_alone;
  1302.         return $this;
  1303.     }
  1305.     public function getIsCanDoHisBusinessAlone(): ?bool
  1306.     {
  1307.         return $this->is_can_do_his_business_alone;
  1308.     }
  1310.     public function setIsCanDoHisBusinessAlone(bool $is_can_do_his_business_alone): self
  1311.     {
  1312.         $this->is_can_do_his_business_alone = $is_can_do_his_business_alone;
  1314.         return $this;
  1315.     }
  1317.     public function getIsFallsSleepEasily(): ?bool
  1318.     {
  1319.         return $this->is_falls_sleep_easily;
  1320.     }
  1322.     public function setIsFallsSleepEasily(bool $is_falls_sleep_easily): self
  1323.     {
  1324.         $this->is_falls_sleep_easily = $is_falls_sleep_easily;
  1326.         return $this;
  1327.     }
  1329.     /**
  1330.      * @return Collection|SchoolAbsenceAndDelay[]
  1331.      */
  1332.     public function getSchoolAbsenceAndDelays(): Collection
  1333.     {
  1334.         return $this->schoolAbsenceAndDelays;
  1335.     }
  1337.     public function addSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1338.     {
  1339.         if (!$this->schoolAbsenceAndDelays->contains($schoolAbsenceAndDelay)) {
  1340.             $this->schoolAbsenceAndDelays[] = $schoolAbsenceAndDelay;
  1341.             $schoolAbsenceAndDelay->setStudentRegistration($this);
  1342.         }
  1344.         return $this;
  1345.     }
  1347.     public function removeSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1348.     {
  1349.         if ($this->schoolAbsenceAndDelays->removeElement($schoolAbsenceAndDelay)) {
  1350.             // set the owning side to null (unless already changed)
  1351.             if ($schoolAbsenceAndDelay->getStudentRegistration() === $this) {
  1352.                 $schoolAbsenceAndDelay->setStudentRegistration(null);
  1353.             }
  1354.         }
  1356.         return $this;
  1357.     }
  1359.     public function getDelayByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1360.         $minute = 0;
  1361.         $heure = 0;
  1362.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1363.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1364.                 if ($schoolAbsenceAndDelay->getSituation() == 'RETARD') {
  1365.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1366.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1367.                     }
  1369.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1370.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1371.                     }
  1372.                 }
  1373.             }
  1374.         }
  1376.         $heure = ceil($heure + ($minute / 60));
  1377.         
  1378.         return $heure;
  1379.     }
  1381.     public function getAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1382.         $minute = 0;
  1383.         $heure = 0;
  1384.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1385.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1386.                 if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1387.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1388.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1389.                     }
  1391.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1392.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1393.                     }
  1394.                 }
  1395.             }
  1396.         }
  1398.         $heure = ceil($heure + ($minute / 60));
  1399.         
  1400.         return $heure;
  1401.     }
  1403.     /**
  1404.      * @return Collection|SettingDocumentToProvide[]
  1405.      */
  1406.     public function getDocumentProvides(): Collection
  1407.     {
  1408.         return $this->documentProvides;
  1409.     }
  1411.     public function addDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1412.     {
  1413.         if (!$this->documentProvides->contains($documentProvide)) {
  1414.             $this->documentProvides[] = $documentProvide;
  1415.         }
  1417.         return $this;
  1418.     }
  1420.     public function removeDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1421.     {
  1422.         $this->documentProvides->removeElement($documentProvide);
  1424.         return $this;
  1425.     }
  1427.     /**
  1428.      * @return Collection|CommunicationMessage[]
  1429.      */
  1430.     public function getCommunicationMessages(): Collection
  1431.     {
  1432.         return $this->communicationMessages;
  1433.     }
  1435.     public function addCommunicationMessage(CommunicationMessage $communicationMessage): self
  1436.     {
  1437.         if (!$this->communicationMessages->contains($communicationMessage)) {
  1438.             $this->communicationMessages[] = $communicationMessage;
  1439.             $communicationMessage->addStudentRegistration($this);
  1440.         }
  1442.         return $this;
  1443.     }
  1445.     public function removeCommunicationMessage(CommunicationMessage $communicationMessage): self
  1446.     {
  1447.         if ($this->communicationMessages->removeElement($communicationMessage)) {
  1448.             $communicationMessage->removeStudentRegistration($this);
  1449.         }
  1451.         return $this;
  1452.     }
  1454.     public function getIsNew(): ?bool
  1455.     {
  1456.         return $this->is_new;
  1457.     }
  1459.     public function setIsNew(bool $is_new): self
  1460.     {
  1461.         $this->is_new = $is_new;
  1463.         return $this;
  1464.     }
  1466.     /**
  1467.      * @return Collection|StockStudentKitEntry[]
  1468.      */
  1469.     public function getStockStudentKitEntries(): Collection
  1470.     {
  1471.         return $this->stockStudentKitEntries;
  1472.     }
  1474.     public function addStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1475.     {
  1476.         if (!$this->stockStudentKitEntries->contains($stockStudentKitEntry)) {
  1477.             $this->stockStudentKitEntries[] = $stockStudentKitEntry;
  1478.             $stockStudentKitEntry->setRegistrationStudent($this);
  1479.         }
  1481.         return $this;
  1482.     }
  1484.     public function removeStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1485.     {
  1486.         if ($this->stockStudentKitEntries->removeElement($stockStudentKitEntry)) {
  1487.             // set the owning side to null (unless already changed)
  1488.             if ($stockStudentKitEntry->getRegistrationStudent() === $this) {
  1489.                 $stockStudentKitEntry->setRegistrationStudent(null);
  1490.             }
  1491.         }
  1493.         return $this;
  1494.     }
  1496.     /**
  1497.      * @return Collection|StockKitOut[]
  1498.      */
  1499.     public function getStockKitOuts(): Collection
  1500.     {
  1501.         return $this->stockKitOuts;
  1502.     }
  1504.     public function addStockKitOut(StockKitOut $stockKitOut): self
  1505.     {
  1506.         if (!$this->stockKitOuts->contains($stockKitOut)) {
  1507.             $this->stockKitOuts[] = $stockKitOut;
  1508.             $stockKitOut->setRegistrationStudent($this);
  1509.         }
  1511.         return $this;
  1512.     }
  1514.     public function removeStockKitOut(StockKitOut $stockKitOut): self
  1515.     {
  1516.         if ($this->stockKitOuts->removeElement($stockKitOut)) {
  1517.             // set the owning side to null (unless already changed)
  1518.             if ($stockKitOut->getRegistrationStudent() === $this) {
  1519.                 $stockKitOut->setRegistrationStudent(null);
  1520.             }
  1521.         }
  1523.         return $this;
  1524.     }
  1526.     public function getPortalLogin(): ?string
  1527.     {
  1528.         return $this->portal_login;
  1529.     }
  1531.     public function setPortalLogin(?string $portal_login): self
  1532.     {
  1533.         $this->portal_login = $portal_login;
  1535.         return $this;
  1536.     }
  1538.     public function getPortalPassword(): ?string
  1539.     {
  1540.         return $this->portal_password;
  1541.     }
  1543.     public function setPortalPassword(?string $portal_password): self
  1544.     {
  1545.         $this->portal_password = $portal_password;
  1547.         return $this;
  1548.     }
  1550.     /**
  1551.      * @return Collection|AccountingCredit[]
  1552.      */
  1553.     public function getAccountingCredits(): Collection
  1554.     {
  1555.         return $this->accountingCredits;
  1556.     }
  1558.     public function addAccountingCredit(AccountingCredit $accountingCredit): self
  1559.     {
  1560.         if (!$this->accountingCredits->contains($accountingCredit)) {
  1561.             $this->accountingCredits[] = $accountingCredit;
  1562.             $accountingCredit->setStudentRegistration($this);
  1563.         }
  1565.         return $this;
  1566.     }
  1568.     public function removeAccountingCredit(AccountingCredit $accountingCredit): self
  1569.     {
  1570.         if ($this->accountingCredits->removeElement($accountingCredit)) {
  1571.             // set the owning side to null (unless already changed)
  1572.             if ($accountingCredit->getStudentRegistration() === $this) {
  1573.                 $accountingCredit->setStudentRegistration(null);
  1574.             }
  1575.         }
  1577.         return $this;
  1578.     }
  1580.     /**
  1581.      * @return Collection|SchoolStudentAverage[]
  1582.      */
  1583.     public function getSchoolStudentAverages(): Collection
  1584.     {
  1585.         return $this->schoolStudentAverages;
  1586.     }
  1588.     public function addSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1589.     {
  1590.         if (!$this->schoolStudentAverages->contains($schoolStudentAverage)) {
  1591.             $this->schoolStudentAverages[] = $schoolStudentAverage;
  1592.             $schoolStudentAverage->setRegistrationStudentRegistration($this);
  1593.         }
  1595.         return $this;
  1596.     }
  1598.     public function removeSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1599.     {
  1600.         if ($this->schoolStudentAverages->removeElement($schoolStudentAverage)) {
  1601.             // set the owning side to null (unless already changed)
  1602.             if ($schoolStudentAverage->getRegistrationStudentRegistration() === $this) {
  1603.                 $schoolStudentAverage->setRegistrationStudentRegistration(null);
  1604.             }
  1605.         }
  1607.         return $this;
  1608.     }
  1610.     public function computePeriodeAverage(SchoolMatter $schoolMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1611.         if (count($schoolMatter->getSchoolSubMatters()) > 0) {
  1612.             $averages = 0;
  1613.             $periodeAverage = 0;
  1614.             $count = 0;
  1615.             $coeffecient = 0;
  1616.             foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1617.                 $_averages = 0;
  1618.                 $_periodeAverage = 0;
  1619.                 $_count = 0;
  1620.                 $_coeffecient = 0;
  1621.                 foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1622.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  1623.                         if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1624.                             $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1625.                             if (!$schoolStudentAverage->getIsUnclassified()) {
  1626.                                 if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1627.                                     if ($schoolStudentAverage->getSubMatter() != null) {
  1628.                                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1629.                                             $_count ++;
  1630.                                             if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1631.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1632.                                                     $averages += $schoolStudentAverage->getNote();
  1633.                                                     //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1634.                                                     $_coeffecient += 1;
  1635.                                                 }
  1636.                                             }else {
  1637.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1638.                                                     //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getSubMatter()->getCoefficient();
  1639.                                                     //$coeffecient += $schoolStudentAverage->getSubMatter()->getCoefficient();
  1640.                                                     $_averages += $schoolStudentAverage->getNote();
  1641.                                                     $_coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1642.                                                 }
  1643.                                             }
  1644.                                         }
  1645.                                     }
  1646.                                 }
  1647.                             }
  1648.                         }
  1649.                     }
  1650.                 }
  1651.                 
  1652.                 if ($_coeffecient > 0) {
  1653.                     $_periodeAverage = $_averages / $_coeffecient;
  1654.                     $averages += ($_periodeAverage * $schoolSubMatter->getCoefficient()); 
  1655.                     $coeffecient += $schoolSubMatter->getCoefficient(); 
  1656.                 }else {
  1657.                     $_periodeAverage = 999;
  1658.                 }
  1659.             }
  1661.             if ($coeffecient > 0) {
  1662.                 $periodeAverage = $averages / $coeffecient;
  1663.             }else {
  1664.                 $periodeAverage = 999;
  1665.             }
  1667.             return $periodeAverage;
  1668.         }else {
  1669.             $averages = 0;
  1670.             $periodeAverage = 0;
  1671.             $count = 0;
  1672.             $coeffecient = 0;
  1673.             foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1674.                 if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1675.                     $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1676.                     if (!$schoolStudentAverage->getIsUnclassified()) {
  1677.                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1678.                             if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1679.                                 $count++;
  1680.                                 if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1681.                                     if($schoolStudentAverage->getNote() < 999.0){
  1682.                                         $averages += $schoolStudentAverage->getNote();
  1683.                                         //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1684.                                         $coeffecient += 1;
  1685.                                     }
  1686.                                 }else {
  1687.                                     if($schoolStudentAverage->getNote() < 999.0){
  1688.                                         //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getMatter()->getCoefficient();
  1689.                                         //$coeffecient += $schoolStudentAverage->getMatter()->getCoefficient();
  1690.                                         
  1691.                                         $averages += $schoolStudentAverage->getNote();
  1692.                                         $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1693.                                     }
  1694.                                 }
  1695.                             }
  1696.                         }
  1697.                     }
  1698.                 }
  1699.             }
  1700.             
  1701.             if ($coeffecient > 0) {
  1702.                 $periodeAverage = $averages / $coeffecient;
  1703.             }else {
  1704.                 $periodeAverage = 999;
  1705.             }
  1707.             return $periodeAverage;
  1708.         }
  1709.     }
  1711.     public function computeSubPeriodeAverage(SchoolSubMatter $schoolSubMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1712.         $averages = 0;
  1713.         $periodeAverage = 0;
  1714.         $count = 0;
  1715.         $coeffecient = 0;
  1716.         
  1717.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1718.             if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1719.                 $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1720.                 if (!$schoolStudentAverage->getIsUnclassified()) {
  1721.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1722.                         $count++;
  1723.                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1724.                             if($schoolStudentAverage->getNote() < 999){
  1725.                                 $averages += $schoolStudentAverage->getNote();
  1726.                                 //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1727.                                 $coeffecient += 1;
  1728.                             }
  1729.                         }else {
  1730.                             if($schoolStudentAverage->getNote() < 999){
  1731.                                 //$averages += $schoolStudentAverage->getNote() * $schoolSubMatter->getCoefficient();
  1732.                                 //$coeffecient += $schoolSubMatter->getCoefficient();
  1734.                                 $averages += $schoolStudentAverage->getNote();
  1735.                                 $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1736.                             }
  1737.                         }
  1738.                         
  1739.                     }
  1740.                 }
  1741.             }
  1742.         }
  1743.         
  1744.         if ($coeffecient > 0) {
  1745.             $periodeAverage = $averages / $coeffecient;
  1746.         }else {
  1747.             $periodeAverage = 999;
  1748.         }
  1750.         return $periodeAverage;
  1751.     }
  1753.     public function asMatterDone(SchoolMatter $schoolMatter, ReportCard $reportCard){
  1754.         
  1755.         $count = 0;
  1756.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1757.             if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1758.                 
  1759.                 $count++;
  1760.             }
  1761.         }
  1763.         return $count > 0;
  1764.     }
  1766.     public function getAnnualAverage(): ?float
  1767.     {
  1768.         $annual_average = 0;
  1769.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1770.             $annual_average = $schoolReportCard->getAnnualAverage();
  1771.         }
  1772.         return $annual_average;
  1773.     }
  1775.     public function getAnnualRank(): ?string
  1776.     {
  1777.         $annual_rank = 0;
  1778.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1779.             $annual_rank = $schoolReportCard->getAnnualRank();
  1780.         }
  1781.         return $annual_rank;
  1782.     }
  1784.     /**
  1785.      * @return Collection|NurseryTimeSheet[]
  1786.      */
  1787.     public function getNurseryTimeSheets(): Collection
  1788.     {
  1789.         return $this->nurseryTimeSheets;
  1790.     }
  1792.     public function addNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1793.     {
  1794.         if (!$this->nurseryTimeSheets->contains($nurseryTimeSheet)) {
  1795.             $this->nurseryTimeSheets[] = $nurseryTimeSheet;
  1796.             $nurseryTimeSheet->setRegistrationStudentRegistration($this);
  1797.         }
  1799.         return $this;
  1800.     }
  1802.     public function removeNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1803.     {
  1804.         if ($this->nurseryTimeSheets->removeElement($nurseryTimeSheet)) {
  1805.             // set the owning side to null (unless already changed)
  1806.             if ($nurseryTimeSheet->getRegistrationStudentRegistration() === $this) {
  1807.                 $nurseryTimeSheet->setRegistrationStudentRegistration(null);
  1808.             }
  1809.         }
  1811.         return $this;
  1812.     }
  1814.     /**
  1815.      * @return Collection|SchoolTeacherCallSheetLine[]
  1816.      */
  1817.     public function getSchoolTeacherCallSheetLines(): Collection
  1818.     {
  1819.         return $this->schoolTeacherCallSheetLines;
  1820.     }
  1822.     public function addSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1823.     {
  1824.         if (!$this->schoolTeacherCallSheetLines->contains($schoolTeacherCallSheetLine)) {
  1825.             $this->schoolTeacherCallSheetLines[] = $schoolTeacherCallSheetLine;
  1826.             $schoolTeacherCallSheetLine->setRegistrationStudentRegistration($this);
  1827.         }
  1829.         return $this;
  1830.     }
  1832.     public function removeSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1833.     {
  1834.         if ($this->schoolTeacherCallSheetLines->removeElement($schoolTeacherCallSheetLine)) {
  1835.             // set the owning side to null (unless already changed)
  1836.             if ($schoolTeacherCallSheetLine->getRegistrationStudentRegistration() === $this) {
  1837.                 $schoolTeacherCallSheetLine->setRegistrationStudentRegistration(null);
  1838.             }
  1839.         }
  1841.         return $this;
  1842.     }
  1844.     public function getJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1845.         $minute = 0;
  1846.         $heure = 0;
  1847.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1848.             if ($schoolAbsenceAndDelay->getIsJustify()) {
  1849.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1850.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1851.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1852.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1853.                         }
  1855.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1856.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1857.                         }
  1858.                     }
  1859.                 }
  1860.             }
  1861.         }
  1863.         $heure = ceil($heure + ($minute / 60));
  1864.         
  1865.         return $heure;
  1866.     }
  1868.     public function getNotJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1869.         $minute = 0;
  1870.         $heure = 0;
  1871.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1872.             if (!$schoolAbsenceAndDelay->getIsJustify()) {
  1873.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1874.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1875.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1876.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1877.                         }
  1879.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1880.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1881.                         }
  1882.                     }
  1883.                 }
  1884.             }
  1885.         }
  1887.         $heure = ceil($heure + ($minute / 60));
  1888.         
  1889.         return $heure;
  1890.     }
  1892.     public function isReported(){
  1893.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1894.             if ($accountingStudentRegistrationFee->getIsReported()) {
  1895.                 return true;
  1896.                 break;
  1897.             }
  1898.         }
  1900.         return false;
  1901.     }
  1903.     public function getNurseryPresence(DateTimeImmutable $startDate, DateTimeImmutable $endDate){
  1904.         
  1905.         $data = new ArrayCollection();
  1906.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1907.             if ($startDate <= $schoolTeacherCallSheetLine->getCreateDate() && $schoolTeacherCallSheetLine->getCreateDate() <= $endDate) {
  1908.                 $data->add($schoolTeacherCallSheetLine);
  1909.             }
  1910.         }
  1912.         return $data;
  1913.     }
  1915.     /**
  1916.      * @return Collection|AccountingChequeTrackingLine[]
  1917.      */
  1918.     public function getAccountingChequeTrackingLines(): Collection
  1919.     {
  1920.         return $this->accountingChequeTrackingLines;
  1921.     }
  1923.     public function addAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1924.     {
  1925.         if (!$this->accountingChequeTrackingLines->contains($accountingChequeTrackingLine)) {
  1926.             $this->accountingChequeTrackingLines[] = $accountingChequeTrackingLine;
  1927.             $accountingChequeTrackingLine->setRegistrationStudentRegistration($this);
  1928.         }
  1930.         return $this;
  1931.     }
  1933.     public function removeAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1934.     {
  1935.         if ($this->accountingChequeTrackingLines->removeElement($accountingChequeTrackingLine)) {
  1936.             // set the owning side to null (unless already changed)
  1937.             if ($accountingChequeTrackingLine->getRegistrationStudentRegistration() === $this) {
  1938.                 $accountingChequeTrackingLine->setRegistrationStudentRegistration(null);
  1939.             }
  1940.         }
  1942.         return $this;
  1943.     }
  1945.     public function getAbsenceStatus($day){
  1946.         $nb = 0;
  1947.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1948.             //if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getSchoolTeacherCallSheet()->getSettingTimeTable() == $settingTimeTable) {
  1949.             if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getIsAbsent()) {
  1950.                 $nb++;
  1951.             }
  1952.         }
  1954.         return $nb;
  1955.     }
  1957.     /**
  1958.      * @return Collection|SchoolReportCardAbsence[]
  1959.      */
  1960.     public function getSchoolReportCardAbsences(): Collection
  1961.     {
  1962.         return $this->schoolReportCardAbsences;
  1963.     }
  1965.     public function addSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1966.     {
  1967.         if (!$this->schoolReportCardAbsences->contains($schoolReportCardAbsence)) {
  1968.             $this->schoolReportCardAbsences[] = $schoolReportCardAbsence;
  1969.             $schoolReportCardAbsence->setStudentRegistration($this);
  1970.         }
  1972.         return $this;
  1973.     }
  1975.     public function removeSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1976.     {
  1977.         if ($this->schoolReportCardAbsences->removeElement($schoolReportCardAbsence)) {
  1978.             // set the owning side to null (unless already changed)
  1979.             if ($schoolReportCardAbsence->getStudentRegistration() === $this) {
  1980.                 $schoolReportCardAbsence->setStudentRegistration(null);
  1981.             }
  1982.         }
  1984.         return $this;
  1985.     }
  1987.     /**
  1988.      * @return Collection|WavePayment[]
  1989.      */
  1990.     public function getWavePayments(): Collection
  1991.     {
  1992.         return $this->wavePayments;
  1993.     }
  1995.     public function addWavePayment(WavePayment $wavePayment): self
  1996.     {
  1997.         if (!$this->wavePayments->contains($wavePayment)) {
  1998.             $this->wavePayments[] = $wavePayment;
  1999.             $wavePayment->setStudentRegistration($this);
  2000.         }
  2002.         return $this;
  2003.     }
  2005.     public function removeWavePayment(WavePayment $wavePayment): self
  2006.     {
  2007.         if ($this->wavePayments->removeElement($wavePayment)) {
  2008.             // set the owning side to null (unless already changed)
  2009.             if ($wavePayment->getStudentRegistration() === $this) {
  2010.                 $wavePayment->setStudentRegistration(null);
  2011.             }
  2012.         }
  2014.         return $this;
  2015.     }
  2017.     public function getSchoolAverage(SchoolAverage $schoolAverage){
  2018.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2019.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2020.                 if ($schoolStudentAverage->getNote() == 999 || $schoolStudentAverage->getIsUnclassified()) {
  2021.                     return false;
  2022.                 }
  2024.                 return $schoolStudentAverage->getNote();
  2025.             }
  2026.         }
  2028.         return false;
  2029.     }
  2031.    
  2033.     public function getSchoolAverageSub(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2034.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2035.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2036.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2037.                     if ($schoolStudentAverage->getNote() == 999 || $schoolStudentAverage->getIsUnclassified()) {
  2038.                         return false;
  2039.                     }
  2040.                     return $schoolStudentAverage->getNote();
  2041.                 }
  2042.             }
  2043.         }
  2045.         return false;
  2046.     }
  2048.     public function getSchoolAverageMaterLabel(SchoolAverage $schoolAverage){
  2049.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2050.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2051.                 if ($schoolStudentAverage->getSubMatter()) {
  2052.                     return $schoolStudentAverage->getSubMatter()->getCode();
  2053.                 }
  2054.                 
  2055.             }
  2056.         }
  2058.         return false;
  2059.     }
  2061.     public function getSchoolAverageCoeff(SchoolAverage $schoolAverage){
  2062.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2063.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2064.                 return $schoolStudentAverage->getCoefficient();
  2065.             }
  2066.         }
  2068.         return false;
  2069.     }
  2071.     public function getSchoolSubAverageCoeff(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2072.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2073.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2074.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2075.                     return $schoolStudentAverage->getCoefficient();
  2076.                 }
  2077.             }
  2078.         }
  2080.         return false;
  2081.     }
  2083.     public function average_report_card(SchoolYearPeriode $schoolYearPeriode, SchoolMatter $schoolMatter){
  2084.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2085.             if ($schoolAverageReportCard->getMatter() == $schoolMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2086.                 return $schoolAverageReportCard;
  2087.             }
  2088.         }
  2090.         return new SchoolAverageReportCard();
  2091.     }
  2093.     public function average_report_card_sub(SchoolYearPeriode $schoolYearPeriode, SchoolSubMatter $schoolSubMatter){
  2094.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2095.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2096.                 return $schoolAverageReportCard;
  2097.             }
  2098.         }
  2100.         return new SchoolAverageReportCard();
  2101.     }
  2103.     public function annual_average_report_card(SchoolMatter $schoolMatter){
  2104.         $averageReportCard = new SchoolAverageReportCard();
  2105.         
  2106.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2107.             if ($schoolAverageReportCard->getMatter() == $schoolMatter) {
  2108.                 $averageReportCard = $schoolAverageReportCard;
  2109.             }
  2110.         }
  2112.         return $averageReportCard;
  2113.     }
  2115.     public function annual_average_report_card_sub(SchoolSubMatter $schoolSubMatter){
  2116.         $averageReportCard = new SchoolAverageReportCard();
  2118.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2119.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2120.                 $averageReportCard = $schoolAverageReportCard;
  2121.             }
  2122.         }
  2124.         return $averageReportCard;
  2125.     }
  2127.     public function last_report_card(){
  2128.         $reportCard = new SchoolReportCard();
  2130.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  2131.             //if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2132.                 $reportCard = $schoolReportCard;
  2133.             //}
  2134.         }
  2136.         return $reportCard;
  2137.     }
  2139.     public function average_report_card_type(SchoolYearPeriode $schoolYearPeriode, SchoolMatterType $schoolMatterType){
  2140.         $sCoeff = 0;
  2141.         $sXCoeff = 0;
  2142.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2143.             if ($schoolAverageReportCard->getMatter()->getMatterType() == $schoolMatterType && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2144.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2145.                 $sCoeff += $schoolAverageReportCard->getCoefficient();
  2146.             }
  2147.         }
  2149.         if ($sCoeff > 0) {
  2150.             return ($sXCoeff / $sCoeff);
  2151.         }
  2153.         return 0;
  2154.     }
  2156.     public function total_xaverage_report_card(SchoolYearPeriode $schoolYearPeriode){
  2157.         $sXCoeff = 0;
  2158.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2159.             if ($schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2160.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2161.             }
  2162.         }
  2164.         return $sXCoeff;
  2165.     }
  2167.     /**
  2168.      * @return Collection|RegistrationStudentContact[]
  2169.      */
  2170.     public function getRegistrationStudentContacts(): Collection
  2171.     {
  2172.         return $this->registrationStudentContacts;
  2173.     }
  2175.     public function addRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2176.     {
  2177.         if (!$this->registrationStudentContacts->contains($registrationStudentContact)) {
  2178.             $this->registrationStudentContacts[] = $registrationStudentContact;
  2179.             $registrationStudentContact->setRegistrationStudentRegistration($this);
  2180.         }
  2182.         return $this;
  2183.     }
  2185.     public function removeRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2186.     {
  2187.         if ($this->registrationStudentContacts->removeElement($registrationStudentContact)) {
  2188.             // set the owning side to null (unless already changed)
  2189.             if ($registrationStudentContact->getRegistrationStudentRegistration() === $this) {
  2190.                 $registrationStudentContact->setRegistrationStudentRegistration(null);
  2191.             }
  2192.         }
  2194.         return $this;
  2195.     }
  2197.     /**
  2198.      * @return Collection|TransportCallSheetLine[]
  2199.      */
  2200.     public function getTransportCallSheetLines(): Collection
  2201.     {
  2202.         return $this->transportCallSheetLines;
  2203.     }
  2205.     public function addTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2206.     {
  2207.         if (!$this->transportCallSheetLines->contains($transportCallSheetLine)) {
  2208.             $this->transportCallSheetLines[] = $transportCallSheetLine;
  2209.             $transportCallSheetLine->setRegistrationStudentRegistration($this);
  2210.         }
  2212.         return $this;
  2213.     }
  2215.     public function removeTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2216.     {
  2217.         if ($this->transportCallSheetLines->removeElement($transportCallSheetLine)) {
  2218.             // set the owning side to null (unless already changed)
  2219.             if ($transportCallSheetLine->getRegistrationStudentRegistration() === $this) {
  2220.                 $transportCallSheetLine->setRegistrationStudentRegistration(null);
  2221.             }
  2222.         }
  2224.         return $this;
  2225.     }
  2227.     /**
  2228.      * @return Collection|StockExitSlip[]
  2229.      */
  2230.     public function getStockExitSlips(): Collection
  2231.     {
  2232.         return $this->stockExitSlips;
  2233.     }
  2235.     public function addStockExitSlip(StockExitSlip $stockExitSlip): self
  2236.     {
  2237.         if (!$this->stockExitSlips->contains($stockExitSlip)) {
  2238.             $this->stockExitSlips[] = $stockExitSlip;
  2239.             $stockExitSlip->setRegistrationStudentRegistration($this);
  2240.         }
  2242.         return $this;
  2243.     }
  2245.     public function removeStockExitSlip(StockExitSlip $stockExitSlip): self
  2246.     {
  2247.         if ($this->stockExitSlips->removeElement($stockExitSlip)) {
  2248.             // set the owning side to null (unless already changed)
  2249.             if ($stockExitSlip->getRegistrationStudentRegistration() === $this) {
  2250.                 $stockExitSlip->setRegistrationStudentRegistration(null);
  2251.             }
  2252.         }
  2254.         return $this;
  2255.     }
  2257.     public function getTotalSchooling(){
  2258.         $total = 0;
  2260.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2261.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2262.                 $total += $accountingStudentRegistrationFee->getAmount();
  2263.             }
  2264.         }
  2266.         return $total;
  2267.     }
  2269.     public function getSchooling(){
  2270.         $data = new ArrayCollection();
  2272.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2273.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2274.                 $data->add($accountingStudentRegistrationFee);
  2275.             }
  2276.         }
  2278.         return $data;
  2279.     }
  2281.     public function getFirstPayment(){
  2282.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  2283.             return $accountingStudentRegistrationPayment->getAmount();
  2284.         }
  2286.         return 0;
  2287.     }
  2289.     public function getIsAuthorizedAlone(): ?bool
  2290.     {
  2291.         return $this->is_authorized_alone;
  2292.     }
  2294.     public function setIsAuthorizedAlone(bool $is_authorized_alone): self
  2295.     {
  2296.         $this->is_authorized_alone = $is_authorized_alone;
  2298.         return $this;
  2299.     }
  2300. }