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.     public function __construct()
  330.     {
  331.         $this->accountingStudentRegistrationFees = new ArrayCollection();
  332.         $this->schoolReportCards = new ArrayCollection();
  333.         $this->schoolAverageReportCards = new ArrayCollection();
  334.         $this->schoolAssessmentByClasses = new ArrayCollection();
  335.         $this->schoolAssessmentByLevels = new ArrayCollection();
  336.         $this->schoolAssessmentByClassByMatters = new ArrayCollection();
  337.         $this->schoolAssessmentByLevelByMatters = new ArrayCollection();
  338.         $this->is_affected = false;
  339.         $this->is_diet = false;
  340.         $this->is_internal = true;
  341.         $this->is_redoubling = false;
  342.         $this->is_abandonned = false;
  343.         $this->registered_at = new DateTimeImmutable();
  344.         $this->accountingStudentRegistrationPayments = new ArrayCollection();
  345.         $this->registrationClassChanges = new ArrayCollection();
  346.         $this->registrationStudentDowngrades = new ArrayCollection();
  347.         $this->registrationStudentAbandonments = new ArrayCollection();
  348.         $this->registrationTransportCheckpoints = new ArrayCollection();
  350.         $this->as_food_restrictions = false;
  351.         $this->is_meatless_menu = false;
  352.         $this->is_menu_without_pork = false;
  353.         $this->is_can_eat_alone = true;
  354.         $this->is_can_do_his_business_alone = true;
  355.         $this->is_falls_sleep_easily = false;
  356.         $this->schoolAbsenceAndDelays = new ArrayCollection();
  357.         $this->documentProvides = new ArrayCollection();
  358.         $this->communicationMessages = new ArrayCollection();
  360.         $this->is_new = false;
  361.         $this->stockStudentKitEntries = new ArrayCollection();
  362.         $this->stockKitOuts = new ArrayCollection();
  363.         $this->accountingCredits = new ArrayCollection();
  364.         $this->schoolStudentAverages = new ArrayCollection();
  365.         $this->nurseryTimeSheets = new ArrayCollection();
  366.         $this->schoolTeacherCallSheetLines = new ArrayCollection();
  367.         $this->accountingChequeTrackingLines = new ArrayCollection();
  368.         $this->schoolReportCardAbsences = new ArrayCollection();
  369.         $this->wavePayments = new ArrayCollection();
  370.         $this->registrationStudentContacts = new ArrayCollection();
  371.         $this->transportCallSheetLines = new ArrayCollection();
  372.         $this->stockExitSlips = new ArrayCollection();
  373.     }
  375.     public function getName()
  376.     {
  377.         return $this->getStudent()->getName();
  378.     }
  380.     public function __toString()
  381.     {
  382.         return $this->getName().' ['.$this->getClassroom()->getLabel().']'.' ['.$this->getStudent()->getRegistrationNumber().']';
  383.     }
  385.     /**
  386.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  387.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  388.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  389.      * must be able to accept an instance of 'File' as the bundle will inject one here
  390.      * during Doctrine hydration.
  391.      *
  392.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  393.      */
  394.     public function setImageFile(?File $imageFile = null): void
  395.     {
  396.         $this->imageFile = $imageFile;
  398.         if (null !== $imageFile) {
  399.             // It is required that at least one field changes if you are using doctrine
  400.             // otherwise the event listeners won't be called and the file is lost
  401.             $this->updated_at = new \DateTimeImmutable();
  402.         }
  403.     }
  405.     public function getImageFile(): ?File
  406.     {
  407.         return $this->imageFile;
  408.     }
  410.     public function getId(): ?int
  411.     {
  412.         return $this->id;
  413.     }
  415.     public function getEstablishment(): ?Establishment
  416.     {
  417.         return $this->establishment;
  418.     }
  420.     public function setEstablishment(?Establishment $establishment): self
  421.     {
  422.         $this->establishment = $establishment;
  424.         return $this;
  425.     }
  427.     public function getStudent(): ?RegistrationStudent
  428.     {
  429.         return $this->student;
  430.     }
  432.     public function setStudent(?RegistrationStudent $student): self
  433.     {
  434.         $this->student = $student;
  436.         return $this;
  437.     }
  439.     public function getSchoolYear(): ?SchoolYear
  440.     {
  441.         return $this->schoolYear;
  442.     }
  444.     public function setSchoolYear(?SchoolYear $schoolYear): self
  445.     {
  446.         $this->schoolYear = $schoolYear;
  448.         return $this;
  449.     }
  451.     public function getClassroom(): ?SettingClassroom
  452.     {
  453.         return $this->classroom;
  454.     }
  456.     public function setClassroom(?SettingClassroom $classroom): self
  457.     {
  458.         $this->classroom = $classroom;
  460.         return $this;
  461.     }
  463.     public function getCreatedAt(): ?\DateTimeImmutable
  464.     {
  465.         return $this->created_at;
  466.     }
  468.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  469.     {
  470.         $this->created_at = $created_at;
  472.         return $this;
  473.     }
  475.     public function getUpdatedAt(): ?\DateTimeImmutable
  476.     {
  477.         return $this->updated_at;
  478.     }
  480.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  481.     {
  482.         $this->updated_at = $updated_at;
  484.         return $this;
  485.     }
  487.     public function getCreatedBy(): ?int
  488.     {
  489.         return $this->created_by;
  490.     }
  492.     public function setCreatedBy(int $created_by): self
  493.     {
  494.         $this->created_by = $created_by;
  496.         return $this;
  497.     }
  499.     public function getUpdatedBy(): ?int
  500.     {
  501.         return $this->updated_by;
  502.     }
  504.     public function setUpdatedBy(int $updated_by): self
  505.     {
  506.         $this->updated_by = $updated_by;
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection|AccountingStudentRegistrationFee[]
  513.      */
  514.     public function getAccountingStudentRegistrationFees(): Collection
  515.     {
  516.         return $this->accountingStudentRegistrationFees;
  517.     }
  519.     public function addAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  520.     {
  521.         if (!$this->accountingStudentRegistrationFees->contains($accountingStudentRegistrationFee)) {
  522.             $this->accountingStudentRegistrationFees[] = $accountingStudentRegistrationFee;
  523.             $accountingStudentRegistrationFee->setStudentRegistration($this);
  524.         }
  526.         return $this;
  527.     }
  529.     public function removeAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  530.     {
  531.         if ($this->accountingStudentRegistrationFees->removeElement($accountingStudentRegistrationFee)) {
  532.             // set the owning side to null (unless already changed)
  533.             if ($accountingStudentRegistrationFee->getStudentRegistration() === $this) {
  534.                 $accountingStudentRegistrationFee->setStudentRegistration(null);
  535.             }
  536.         }
  538.         return $this;
  539.     }
  541.     /**
  542.      * @return Collection|SchoolReportCard[]
  543.      */
  544.     public function getSchoolReportCards(): Collection
  545.     {
  546.         return $this->schoolReportCards;
  547.     }
  549.     public function addSchoolReportCard(SchoolReportCard $schoolReportCard): self
  550.     {
  551.         if (!$this->schoolReportCards->contains($schoolReportCard)) {
  552.             $this->schoolReportCards[] = $schoolReportCard;
  553.             $schoolReportCard->setStudentRegistration($this);
  554.         }
  556.         return $this;
  557.     }
  559.    
  560.     public function getOrderedSchoolReportCards(SchoolReportCardRepository $schoolReportCardRepository)
  561.     {
  562.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  563.         ->innerJoin('entity.schoolYearPeriode', 'schoolYearPeriode')
  564.         ->addSelect('schoolYearPeriode')
  566.         ->andWhere('entity.studentRegistration = :studentRegistration')
  567.         ->setParameter('studentRegistration', $this)
  569.         ->orderBy('schoolYearPeriode.code', 'ASC')
  570.         ->getQuery()
  571.         ->getResult();
  573.         return $schoolReportCards;
  574.     }
  576.     public function removeSchoolReportCard(SchoolReportCard $schoolReportCard): self
  577.     {
  578.         if ($this->schoolReportCards->removeElement($schoolReportCard)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($schoolReportCard->getStudentRegistration() === $this) {
  581.                 $schoolReportCard->setStudentRegistration(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     /**
  589.      * @return Collection|SchoolAverageReportCard[]
  590.      */
  591.     public function getSchoolAverageReportCards(): Collection
  592.     {
  593.         return $this->schoolAverageReportCards;
  594.     }
  596.     public function addSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  597.     {
  598.         if (!$this->schoolAverageReportCards->contains($schoolAverageReportCard)) {
  599.             $this->schoolAverageReportCards[] = $schoolAverageReportCard;
  600.             $schoolAverageReportCard->setStudentRegistration($this);
  601.         }
  603.         return $this;
  604.     }
  606.     public function removeSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  607.     {
  608.         if ($this->schoolAverageReportCards->removeElement($schoolAverageReportCard)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($schoolAverageReportCard->getStudentRegistration() === $this) {
  611.                 $schoolAverageReportCard->setStudentRegistration(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     /**
  619.      * @return Collection|SchoolAssessmentByClass[]
  620.      */
  621.     public function getSchoolAssessmentByClasses(): Collection
  622.     {
  623.         return $this->schoolAssessmentByClasses;
  624.     }
  626.     public function addSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  627.     {
  628.         if (!$this->schoolAssessmentByClasses->contains($schoolAssessmentByClass)) {
  629.             $this->schoolAssessmentByClasses[] = $schoolAssessmentByClass;
  630.             $schoolAssessmentByClass->setStudentRegistration($this);
  631.         }
  633.         return $this;
  634.     }
  636.     public function removeSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  637.     {
  638.         if ($this->schoolAssessmentByClasses->removeElement($schoolAssessmentByClass)) {
  639.             // set the owning side to null (unless already changed)
  640.             if ($schoolAssessmentByClass->getStudentRegistration() === $this) {
  641.                 $schoolAssessmentByClass->setStudentRegistration(null);
  642.             }
  643.         }
  645.         return $this;
  646.     }
  648.     /**
  649.      * @return Collection|SchoolAssessmentByLevel[]
  650.      */
  651.     public function getSchoolAssessmentByLevels(): Collection
  652.     {
  653.         return $this->schoolAssessmentByLevels;
  654.     }
  656.     public function addSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  657.     {
  658.         if (!$this->schoolAssessmentByLevels->contains($schoolAssessmentByLevel)) {
  659.             $this->schoolAssessmentByLevels[] = $schoolAssessmentByLevel;
  660.             $schoolAssessmentByLevel->setStudentRegistration($this);
  661.         }
  663.         return $this;
  664.     }
  666.     public function removeSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  667.     {
  668.         if ($this->schoolAssessmentByLevels->removeElement($schoolAssessmentByLevel)) {
  669.             // set the owning side to null (unless already changed)
  670.             if ($schoolAssessmentByLevel->getStudentRegistration() === $this) {
  671.                 $schoolAssessmentByLevel->setStudentRegistration(null);
  672.             }
  673.         }
  675.         return $this;
  676.     }
  678.     /**
  679.      * @return Collection|SchoolAssessmentByClassByMatter[]
  680.      */
  681.     public function getSchoolAssessmentByClassByMatters(): Collection
  682.     {
  683.         return $this->schoolAssessmentByClassByMatters;
  684.     }
  686.     public function addSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  687.     {
  688.         if (!$this->schoolAssessmentByClassByMatters->contains($schoolAssessmentByClassByMatter)) {
  689.             $this->schoolAssessmentByClassByMatters[] = $schoolAssessmentByClassByMatter;
  690.             $schoolAssessmentByClassByMatter->setStudentRegistration($this);
  691.         }
  693.         return $this;
  694.     }
  696.     public function removeSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  697.     {
  698.         if ($this->schoolAssessmentByClassByMatters->removeElement($schoolAssessmentByClassByMatter)) {
  699.             // set the owning side to null (unless already changed)
  700.             if ($schoolAssessmentByClassByMatter->getStudentRegistration() === $this) {
  701.                 $schoolAssessmentByClassByMatter->setStudentRegistration(null);
  702.             }
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection|SchoolAssessmentByLevelByMatter[]
  710.      */
  711.     public function getSchoolAssessmentByLevelByMatters(): Collection
  712.     {
  713.         return $this->schoolAssessmentByLevelByMatters;
  714.     }
  716.     public function addSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  717.     {
  718.         if (!$this->schoolAssessmentByLevelByMatters->contains($schoolAssessmentByLevelByMatter)) {
  719.             $this->schoolAssessmentByLevelByMatters[] = $schoolAssessmentByLevelByMatter;
  720.             $schoolAssessmentByLevelByMatter->setStudentRegistration($this);
  721.         }
  723.         return $this;
  724.     }
  726.     public function removeSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  727.     {
  728.         if ($this->schoolAssessmentByLevelByMatters->removeElement($schoolAssessmentByLevelByMatter)) {
  729.             // set the owning side to null (unless already changed)
  730.             if ($schoolAssessmentByLevelByMatter->getStudentRegistration() === $this) {
  731.                 $schoolAssessmentByLevelByMatter->setStudentRegistration(null);
  732.             }
  733.         }
  735.         return $this;
  736.     }
  738.     public function getIsRedoubling(): ?bool
  739.     {
  740.         return $this->is_redoubling;
  741.     }
  743.     public function setIsRedoubling(bool $is_redoubling): self
  744.     {
  745.         $this->is_redoubling = $is_redoubling;
  747.         return $this;
  748.     }
  750.     public function getIsDiet(): ?bool
  751.     {
  752.         return $this->is_diet;
  753.     }
  755.     public function setIsDiet(bool $is_diet): self
  756.     {
  757.         $this->is_diet = $is_diet;
  759.         return $this;
  760.     }
  762.     public function getIsInternal(): ?bool
  763.     {
  764.         return $this->is_internal;
  765.     }
  767.     public function setIsInternal(bool $is_internal): self
  768.     {
  769.         $this->is_internal = $is_internal;
  771.         return $this;
  772.     }
  774.     public function getIsAffected(): ?bool
  775.     {
  776.         return $this->is_affected;
  777.     }
  779.     public function setIsAffected(bool $is_affected): self
  780.     {
  781.         $this->is_affected = $is_affected;
  783.         return $this;
  784.     }
  786.     public function getRegisteredAt(): ?\DateTimeImmutable
  787.     {
  788.         return $this->registered_at;
  789.     }
  791.     public function setRegisteredAt(\DateTimeImmutable $registered_at): self
  792.     {
  793.         $this->registered_at = $registered_at;
  795.         return $this;
  796.     }
  798.     public function getGleAmount(){
  799.         $amount = 0;
  800.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $fee) {
  801.             if (!$fee->getIsArchived()) {
  802.                 $amount = $amount + $fee->getAmount();
  803.             }
  804.         }
  806.         return $amount;
  807.     }
  809.     public function getAmountPaid(){
  810.         $amount = 0;
  811.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  812.             //if (!$accountingStudentRegistrationPayment->isCanBeShow()) {
  813.                 $amount = $amount + $accountingStudentRegistrationPayment->getAmount();
  814.             //}
  815.         }
  817.         $payArchived = 0;
  818.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  819.             if ($accountingStudentRegistrationFee->getIsArchived()) {
  820.                 $payArchived = $payArchived + $accountingStudentRegistrationFee->getAmountPaid();
  821.             }
  822.             
  823.         }
  826.         return $amount - $payArchived;
  827.     }
  829.     public function getAmountCancel(): ?float
  830.     {
  831.         $amountCancel = 0;
  832.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  833.             //if (!$accountingStudentRegistrationFee->getIsArchived()) {
  834.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountReported();
  835.             //}
  836.         }
  837.         
  838.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  839.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  840.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountCancel();
  841.             }
  842.         }
  843.         
  844.         return $amountCancel;
  845.     }
  847.     public function getAmountRest(): ?float
  848.     {
  849.         $amount = ($this->getGleAmount() - ($this->getAmountPaid() + $this->getAmountCancel()));
  850.         return $amount > 0 ? $amount : 0;
  851.     }
  853.     /**
  854.      * @return Collection|AccountingStudentRegistrationPayment[]
  855.      */
  856.     public function getAccountingStudentRegistrationPayments(): Collection
  857.     {
  858.         return $this->accountingStudentRegistrationPayments;
  859.     }
  861.     public function addAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  862.     {
  863.         if (!$this->accountingStudentRegistrationPayments->contains($accountingStudentRegistrationPayment)) {
  864.             $this->accountingStudentRegistrationPayments[] = $accountingStudentRegistrationPayment;
  865.             $accountingStudentRegistrationPayment->setStudentRegistration($this);
  866.         }
  868.         return $this;
  869.     }
  871.     public function removeAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  872.     {
  873.         if ($this->accountingStudentRegistrationPayments->removeElement($accountingStudentRegistrationPayment)) {
  874.             // set the owning side to null (unless already changed)
  875.             if ($accountingStudentRegistrationPayment->getStudentRegistration() === $this) {
  876.                 $accountingStudentRegistrationPayment->setStudentRegistration(null);
  877.             }
  878.         }
  880.         return $this;
  881.     }
  883.     public function getLastAmountPaid(): ?float
  884.     {
  885.         return $this->last_amount_paid;
  886.     }
  888.     public function setLastAmountPaid(?float $last_amount_paid): self
  889.     {
  890.         $this->last_amount_paid = $last_amount_paid;
  892.         return $this;
  893.     }
  895.     public function getLastPaymentId(): ?int
  896.     {
  897.         return $this->last_payment_id;
  898.     }
  900.     public function setLastPaymentId(?int $last_payment_id): self
  901.     {
  902.         $this->last_payment_id = $last_payment_id;
  904.         return $this;
  905.     }
  907.     public function getLastPaymentAt(): ?\DateTimeImmutable
  908.     {
  909.         return $this->last_payment_at;
  910.     }
  912.     public function setLastPaymentAt(?\DateTimeImmutable $last_payment_at): self
  913.     {
  914.         $this->last_payment_at = $last_payment_at;
  916.         return $this;
  917.     }
  919.     public function getImage(): ?string
  920.     {
  921.         return $this->image;
  922.     }
  924.     public function setImage(?string $image): self
  925.     {
  926.         $this->image = $image;
  928.         return $this;
  929.     }
  931.     /**
  932.      * @return Collection|RegistrationClassChange[]
  933.      */
  934.     public function getRegistrationClassChanges(): Collection
  935.     {
  936.         return $this->registrationClassChanges;
  937.     }
  939.     public function addRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  940.     {
  941.         if (!$this->registrationClassChanges->contains($registrationClassChange)) {
  942.             $this->registrationClassChanges[] = $registrationClassChange;
  943.             $registrationClassChange->setStudentRegistration($this);
  944.         }
  946.         return $this;
  947.     }
  949.     public function removeRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  950.     {
  951.         if ($this->registrationClassChanges->removeElement($registrationClassChange)) {
  952.             // set the owning side to null (unless already changed)
  953.             if ($registrationClassChange->getStudentRegistration() === $this) {
  954.                 $registrationClassChange->setStudentRegistration(null);
  955.             }
  956.         }
  958.         return $this;
  959.     }
  961.     /**
  962.      * @return Collection|RegistrationStudentDowngrade[]
  963.      */
  964.     public function getRegistrationStudentDowngrades(): Collection
  965.     {
  966.         return $this->registrationStudentDowngrades;
  967.     }
  969.     public function addRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  970.     {
  971.         if (!$this->registrationStudentDowngrades->contains($registrationStudentDowngrade)) {
  972.             $this->registrationStudentDowngrades[] = $registrationStudentDowngrade;
  973.             $registrationStudentDowngrade->setRegistrationStudentRegistration($this);
  974.         }
  976.         return $this;
  977.     }
  979.     public function removeRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  980.     {
  981.         if ($this->registrationStudentDowngrades->removeElement($registrationStudentDowngrade)) {
  982.             // set the owning side to null (unless already changed)
  983.             if ($registrationStudentDowngrade->getRegistrationStudentRegistration() === $this) {
  984.                 $registrationStudentDowngrade->setRegistrationStudentRegistration(null);
  985.             }
  986.         }
  988.         return $this;
  989.     }
  991.     /**
  992.      * @return Collection|RegistrationStudentAbandonment[]
  993.      */
  994.     public function getRegistrationStudentAbandonments(): Collection
  995.     {
  996.         return $this->registrationStudentAbandonments;
  997.     }
  999.     public function addRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1000.     {
  1001.         if (!$this->registrationStudentAbandonments->contains($registrationStudentAbandonment)) {
  1002.             $this->registrationStudentAbandonments[] = $registrationStudentAbandonment;
  1003.             $registrationStudentAbandonment->setRegistrationStudentRegistration($this);
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     public function removeRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1010.     {
  1011.         if ($this->registrationStudentAbandonments->removeElement($registrationStudentAbandonment)) {
  1012.             // set the owning side to null (unless already changed)
  1013.             if ($registrationStudentAbandonment->getRegistrationStudentRegistration() === $this) {
  1014.                 $registrationStudentAbandonment->setRegistrationStudentRegistration(null);
  1015.             }
  1016.         }
  1018.         return $this;
  1019.     }
  1021.     public function getIsAbandonned(): ?bool
  1022.     {
  1023.         return $this->is_abandonned;
  1024.     }
  1026.     public function setIsAbandonned(bool $is_abandonned): self
  1027.     {
  1028.         $this->is_abandonned = $is_abandonned;
  1030.         return $this;
  1031.     }
  1033.     public function getRegistrationStudentPreRegistration(): ?RegistrationStudentPreRegistration
  1034.     {
  1035.         return $this->registrationStudentPreRegistration;
  1036.     }
  1038.     public function setRegistrationStudentPreRegistration(?RegistrationStudentPreRegistration $registrationStudentPreRegistration): self
  1039.     {
  1040.         $this->registrationStudentPreRegistration = $registrationStudentPreRegistration;
  1042.         return $this;
  1043.     }
  1045.     /**
  1046.      * @return Collection|RegistrationTransportCheckpoint[]
  1047.      */
  1048.     public function getRegistrationTransportCheckpoints(): Collection
  1049.     {
  1050.         return $this->registrationTransportCheckpoints;
  1051.     }
  1053.     public function addRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1054.     {
  1055.         if (!$this->registrationTransportCheckpoints->contains($registrationTransportCheckpoint)) {
  1056.             $this->registrationTransportCheckpoints[] = $registrationTransportCheckpoint;
  1057.             $registrationTransportCheckpoint->setRegistrationStudentRegistration($this);
  1058.         }
  1060.         return $this;
  1061.     }
  1063.     public function removeRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1064.     {
  1065.         if ($this->registrationTransportCheckpoints->removeElement($registrationTransportCheckpoint)) {
  1066.             // set the owning side to null (unless already changed)
  1067.             if ($registrationTransportCheckpoint->getRegistrationStudentRegistration() === $this) {
  1068.                 $registrationTransportCheckpoint->setRegistrationStudentRegistration(null);
  1069.             }
  1070.         }
  1072.         return $this;
  1073.     }
  1075.     public function hasTransportFee(){
  1076.         $reponse = false;
  1077.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1078.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::TRANSPORT_FEE && !$accountingStudentRegistrationFee->getIsCancel() && $accountingStudentRegistrationFee->getAmountPaid() > 0 && !$accountingStudentRegistrationFee->getIsArchived()) {
  1079.                 $reponse = true;
  1080.                 break;
  1081.             }
  1082.         }
  1084.         return $reponse;
  1085.     }
  1087.     public function hasGardeMidiFee(){
  1088.         $reponse = false;
  1089.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1090.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::GARDE_MIDI_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1091.                 $reponse = true;
  1092.                 break;
  1093.             }
  1094.         }
  1096.         return $reponse;
  1097.     }
  1099.     public function hasExtraFee(){
  1100.         $reponse = false;
  1101.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1102.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::ACTIVITE_EXTAT_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1103.                 $reponse = true;
  1104.                 break;
  1105.             }
  1106.         }
  1108.         return $reponse;
  1109.     }
  1111.     public function hasCanteenFee(){
  1112.         $reponse = false;
  1113.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1114.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::CANTINE_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1115.                 $reponse = true;
  1116.                 break;
  1117.             }
  1118.         }
  1120.         return $reponse;
  1121.     }
  1123.     public function hasMobileApp(){
  1124.         $reponse = false;
  1125.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1126.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::MOBILE_APP && !$accountingStudentRegistrationFee->getIsCancel()) {
  1127.                 $reponse = true;
  1128.                 break;
  1129.             }
  1130.         }
  1132.         return $reponse;
  1133.     }
  1135.     public function getAmountDueAt(DateTimeImmutable $dueDate, $category = '0'){
  1136.         
  1137.         $amountDue = 0;
  1138.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1139.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1140.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1141.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() >= 0) {
  1142.                         if ('0' != $category) {
  1143.                             if ($accountingStudentRegistrationFee->getFee()->getCategory() == $category) {
  1144.                                 $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1145.                             }
  1146.                         }else {
  1147.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1148.                         }
  1149.                     }
  1150.                 }
  1151.             }
  1152.         }
  1154.         $amountChequeTracking = 0;
  1155.         foreach ($this->getAccountingChequeTrackingLines() as $key => $accountingChequeTrackingLine) {
  1156.             if ($accountingChequeTrackingLine->getAccountingChequeTracking()->getStatus() == AccountingChequeTracking::EN_TRAITEMENT) {
  1157.                 $amountChequeTracking += $accountingChequeTrackingLine->getAmount();
  1158.             }
  1159.         }
  1160.         
  1161.         return $amountDue - $amountChequeTracking;
  1162.     }
  1164.     public function getAmountDueAtByFee(DateTimeImmutable $dueDate, SettingFee $settingFee){
  1165.         
  1166.         $amountDue = 0;
  1167.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1168.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1169.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1170.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1171.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1172.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1173.                         }
  1174.                     }
  1175.                 }
  1176.             }
  1177.         }
  1178.         
  1179.         return $amountDue;
  1180.     }
  1182.     public function getAmountByFee(SettingFee $settingFee){
  1183.         
  1184.         $amountDue = 0;
  1185.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1186.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1187.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1188.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1189.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1190.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmount();
  1191.                         }
  1192.                     //}
  1193.                 }
  1194.             }
  1195.         }
  1196.         
  1197.         return $amountDue;
  1198.     }
  1200.     public function getAmountPaidByFee(SettingFee $settingFee){
  1201.         
  1202.         $amountDue = 0;
  1203.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1204.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1205.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1206.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1207.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1208.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountPaid();
  1209.                         }
  1210.                     //}
  1211.                 }
  1212.             }
  1213.         }
  1214.         
  1215.         return $amountDue;
  1216.     }
  1218.     public function getAmountRestByFee(SettingFee $settingFee){
  1219.         
  1220.         $amountDue = 0;
  1221.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1222.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1223.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1224.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1225.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1226.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1227.                         }
  1228.                     //}
  1229.                 }
  1230.             }
  1231.         }
  1232.         
  1233.         return $amountDue;
  1234.     }
  1236.     public function getFeeShedulDues(DateTimeImmutable $dueDate){
  1237.         $feeShedulDues = new ArrayCollection();
  1238.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1239.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1240.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1241.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1242.                         $feeShedulDues->add($accountingStudentRegistrationFeeShedul);
  1243.                     }
  1244.                 }
  1245.             }
  1246.         }
  1247.         
  1248.         return $feeShedulDues;
  1249.     }
  1251.     public function getAsFoodRestrictions(): ?bool
  1252.     {
  1253.         return $this->as_food_restrictions;
  1254.     }
  1256.     public function setAsFoodRestrictions(bool $as_food_restrictions): self
  1257.     {
  1258.         $this->as_food_restrictions = $as_food_restrictions;
  1260.         return $this;
  1261.     }
  1263.     public function getIsMeatlessMenu(): ?bool
  1264.     {
  1265.         return $this->is_meatless_menu;
  1266.     }
  1268.     public function setIsMeatlessMenu(bool $is_meatless_menu): self
  1269.     {
  1270.         $this->is_meatless_menu = $is_meatless_menu;
  1272.         return $this;
  1273.     }
  1275.     public function getIsMenuWithoutPork(): ?bool
  1276.     {
  1277.         return $this->is_menu_without_pork;
  1278.     }
  1280.     public function setIsMenuWithoutPork(bool $is_menu_without_pork): self
  1281.     {
  1282.         $this->is_menu_without_pork = $is_menu_without_pork;
  1284.         return $this;
  1285.     }
  1287.     public function getIsCanEatAlone(): ?bool
  1288.     {
  1289.         return $this->is_can_eat_alone;
  1290.     }
  1292.     public function setIsCanEatAlone(bool $is_can_eat_alone): self
  1293.     {
  1294.         $this->is_can_eat_alone = $is_can_eat_alone;
  1296.         return $this;
  1297.     }
  1299.     public function getIsCanDoHisBusinessAlone(): ?bool
  1300.     {
  1301.         return $this->is_can_do_his_business_alone;
  1302.     }
  1304.     public function setIsCanDoHisBusinessAlone(bool $is_can_do_his_business_alone): self
  1305.     {
  1306.         $this->is_can_do_his_business_alone = $is_can_do_his_business_alone;
  1308.         return $this;
  1309.     }
  1311.     public function getIsFallsSleepEasily(): ?bool
  1312.     {
  1313.         return $this->is_falls_sleep_easily;
  1314.     }
  1316.     public function setIsFallsSleepEasily(bool $is_falls_sleep_easily): self
  1317.     {
  1318.         $this->is_falls_sleep_easily = $is_falls_sleep_easily;
  1320.         return $this;
  1321.     }
  1323.     /**
  1324.      * @return Collection|SchoolAbsenceAndDelay[]
  1325.      */
  1326.     public function getSchoolAbsenceAndDelays(): Collection
  1327.     {
  1328.         return $this->schoolAbsenceAndDelays;
  1329.     }
  1331.     public function addSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1332.     {
  1333.         if (!$this->schoolAbsenceAndDelays->contains($schoolAbsenceAndDelay)) {
  1334.             $this->schoolAbsenceAndDelays[] = $schoolAbsenceAndDelay;
  1335.             $schoolAbsenceAndDelay->setStudentRegistration($this);
  1336.         }
  1338.         return $this;
  1339.     }
  1341.     public function removeSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1342.     {
  1343.         if ($this->schoolAbsenceAndDelays->removeElement($schoolAbsenceAndDelay)) {
  1344.             // set the owning side to null (unless already changed)
  1345.             if ($schoolAbsenceAndDelay->getStudentRegistration() === $this) {
  1346.                 $schoolAbsenceAndDelay->setStudentRegistration(null);
  1347.             }
  1348.         }
  1350.         return $this;
  1351.     }
  1353.     public function getDelayByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1354.         $minute = 0;
  1355.         $heure = 0;
  1356.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1357.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1358.                 if ($schoolAbsenceAndDelay->getSituation() == 'RETARD') {
  1359.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1360.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1361.                     }
  1363.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1364.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1365.                     }
  1366.                 }
  1367.             }
  1368.         }
  1370.         $heure = ceil($heure + ($minute / 60));
  1371.         
  1372.         return $heure;
  1373.     }
  1375.     public function getAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1376.         $minute = 0;
  1377.         $heure = 0;
  1378.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1379.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1380.                 if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1381.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1382.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1383.                     }
  1385.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1386.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1387.                     }
  1388.                 }
  1389.             }
  1390.         }
  1392.         $heure = ceil($heure + ($minute / 60));
  1393.         
  1394.         return $heure;
  1395.     }
  1397.     /**
  1398.      * @return Collection|SettingDocumentToProvide[]
  1399.      */
  1400.     public function getDocumentProvides(): Collection
  1401.     {
  1402.         return $this->documentProvides;
  1403.     }
  1405.     public function addDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1406.     {
  1407.         if (!$this->documentProvides->contains($documentProvide)) {
  1408.             $this->documentProvides[] = $documentProvide;
  1409.         }
  1411.         return $this;
  1412.     }
  1414.     public function removeDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1415.     {
  1416.         $this->documentProvides->removeElement($documentProvide);
  1418.         return $this;
  1419.     }
  1421.     /**
  1422.      * @return Collection|CommunicationMessage[]
  1423.      */
  1424.     public function getCommunicationMessages(): Collection
  1425.     {
  1426.         return $this->communicationMessages;
  1427.     }
  1429.     public function addCommunicationMessage(CommunicationMessage $communicationMessage): self
  1430.     {
  1431.         if (!$this->communicationMessages->contains($communicationMessage)) {
  1432.             $this->communicationMessages[] = $communicationMessage;
  1433.             $communicationMessage->addStudentRegistration($this);
  1434.         }
  1436.         return $this;
  1437.     }
  1439.     public function removeCommunicationMessage(CommunicationMessage $communicationMessage): self
  1440.     {
  1441.         if ($this->communicationMessages->removeElement($communicationMessage)) {
  1442.             $communicationMessage->removeStudentRegistration($this);
  1443.         }
  1445.         return $this;
  1446.     }
  1448.     public function getIsNew(): ?bool
  1449.     {
  1450.         return $this->is_new;
  1451.     }
  1453.     public function setIsNew(bool $is_new): self
  1454.     {
  1455.         $this->is_new = $is_new;
  1457.         return $this;
  1458.     }
  1460.     /**
  1461.      * @return Collection|StockStudentKitEntry[]
  1462.      */
  1463.     public function getStockStudentKitEntries(): Collection
  1464.     {
  1465.         return $this->stockStudentKitEntries;
  1466.     }
  1468.     public function addStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1469.     {
  1470.         if (!$this->stockStudentKitEntries->contains($stockStudentKitEntry)) {
  1471.             $this->stockStudentKitEntries[] = $stockStudentKitEntry;
  1472.             $stockStudentKitEntry->setRegistrationStudent($this);
  1473.         }
  1475.         return $this;
  1476.     }
  1478.     public function removeStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1479.     {
  1480.         if ($this->stockStudentKitEntries->removeElement($stockStudentKitEntry)) {
  1481.             // set the owning side to null (unless already changed)
  1482.             if ($stockStudentKitEntry->getRegistrationStudent() === $this) {
  1483.                 $stockStudentKitEntry->setRegistrationStudent(null);
  1484.             }
  1485.         }
  1487.         return $this;
  1488.     }
  1490.     /**
  1491.      * @return Collection|StockKitOut[]
  1492.      */
  1493.     public function getStockKitOuts(): Collection
  1494.     {
  1495.         return $this->stockKitOuts;
  1496.     }
  1498.     public function addStockKitOut(StockKitOut $stockKitOut): self
  1499.     {
  1500.         if (!$this->stockKitOuts->contains($stockKitOut)) {
  1501.             $this->stockKitOuts[] = $stockKitOut;
  1502.             $stockKitOut->setRegistrationStudent($this);
  1503.         }
  1505.         return $this;
  1506.     }
  1508.     public function removeStockKitOut(StockKitOut $stockKitOut): self
  1509.     {
  1510.         if ($this->stockKitOuts->removeElement($stockKitOut)) {
  1511.             // set the owning side to null (unless already changed)
  1512.             if ($stockKitOut->getRegistrationStudent() === $this) {
  1513.                 $stockKitOut->setRegistrationStudent(null);
  1514.             }
  1515.         }
  1517.         return $this;
  1518.     }
  1520.     public function getPortalLogin(): ?string
  1521.     {
  1522.         return $this->portal_login;
  1523.     }
  1525.     public function setPortalLogin(?string $portal_login): self
  1526.     {
  1527.         $this->portal_login = $portal_login;
  1529.         return $this;
  1530.     }
  1532.     public function getPortalPassword(): ?string
  1533.     {
  1534.         return $this->portal_password;
  1535.     }
  1537.     public function setPortalPassword(?string $portal_password): self
  1538.     {
  1539.         $this->portal_password = $portal_password;
  1541.         return $this;
  1542.     }
  1544.     /**
  1545.      * @return Collection|AccountingCredit[]
  1546.      */
  1547.     public function getAccountingCredits(): Collection
  1548.     {
  1549.         return $this->accountingCredits;
  1550.     }
  1552.     public function addAccountingCredit(AccountingCredit $accountingCredit): self
  1553.     {
  1554.         if (!$this->accountingCredits->contains($accountingCredit)) {
  1555.             $this->accountingCredits[] = $accountingCredit;
  1556.             $accountingCredit->setStudentRegistration($this);
  1557.         }
  1559.         return $this;
  1560.     }
  1562.     public function removeAccountingCredit(AccountingCredit $accountingCredit): self
  1563.     {
  1564.         if ($this->accountingCredits->removeElement($accountingCredit)) {
  1565.             // set the owning side to null (unless already changed)
  1566.             if ($accountingCredit->getStudentRegistration() === $this) {
  1567.                 $accountingCredit->setStudentRegistration(null);
  1568.             }
  1569.         }
  1571.         return $this;
  1572.     }
  1574.     /**
  1575.      * @return Collection|SchoolStudentAverage[]
  1576.      */
  1577.     public function getSchoolStudentAverages(): Collection
  1578.     {
  1579.         return $this->schoolStudentAverages;
  1580.     }
  1582.     public function addSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1583.     {
  1584.         if (!$this->schoolStudentAverages->contains($schoolStudentAverage)) {
  1585.             $this->schoolStudentAverages[] = $schoolStudentAverage;
  1586.             $schoolStudentAverage->setRegistrationStudentRegistration($this);
  1587.         }
  1589.         return $this;
  1590.     }
  1592.     public function removeSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1593.     {
  1594.         if ($this->schoolStudentAverages->removeElement($schoolStudentAverage)) {
  1595.             // set the owning side to null (unless already changed)
  1596.             if ($schoolStudentAverage->getRegistrationStudentRegistration() === $this) {
  1597.                 $schoolStudentAverage->setRegistrationStudentRegistration(null);
  1598.             }
  1599.         }
  1601.         return $this;
  1602.     }
  1604.     public function computePeriodeAverage(SchoolMatter $schoolMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1605.         if (count($schoolMatter->getSchoolSubMatters()) > 0) {
  1606.             $averages = 0;
  1607.             $periodeAverage = 0;
  1608.             $count = 0;
  1609.             $coeffecient = 0;
  1610.             foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1611.                 $_averages = 0;
  1612.                 $_periodeAverage = 0;
  1613.                 $_count = 0;
  1614.                 $_coeffecient = 0;
  1615.                 foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1616.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  1617.                         if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1618.                             $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1619.                             if (!$schoolStudentAverage->getIsUnclassified()) {
  1620.                                 if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1621.                                     if ($schoolStudentAverage->getSubMatter() != null) {
  1622.                                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1623.                                             $_count ++;
  1624.                                             if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1625.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1626.                                                     $averages += $schoolStudentAverage->getNote();
  1627.                                                     //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1628.                                                     $_coeffecient += 1;
  1629.                                                 }
  1630.                                             }else {
  1631.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1632.                                                     //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getSubMatter()->getCoefficient();
  1633.                                                     //$coeffecient += $schoolStudentAverage->getSubMatter()->getCoefficient();
  1634.                                                     $_averages += $schoolStudentAverage->getNote();
  1635.                                                     $_coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1636.                                                 }
  1637.                                             }
  1638.                                         }
  1639.                                     }
  1640.                                 }
  1641.                             }
  1642.                         }
  1643.                     }
  1644.                 }
  1645.                 
  1646.                 if ($_coeffecient > 0) {
  1647.                     $_periodeAverage = $_averages / $_coeffecient;
  1648.                     $averages += ($_periodeAverage * $schoolSubMatter->getCoefficient()); 
  1649.                     $coeffecient += $schoolSubMatter->getCoefficient(); 
  1650.                 }else {
  1651.                     $_periodeAverage = 999;
  1652.                 }
  1653.             }
  1655.             if ($coeffecient > 0) {
  1656.                 $periodeAverage = $averages / $coeffecient;
  1657.             }else {
  1658.                 $periodeAverage = 999;
  1659.             }
  1661.             return $periodeAverage;
  1662.         }else {
  1663.             $averages = 0;
  1664.             $periodeAverage = 0;
  1665.             $count = 0;
  1666.             $coeffecient = 0;
  1667.             foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1668.                 if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1669.                     $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1670.                     if (!$schoolStudentAverage->getIsUnclassified()) {
  1671.                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1672.                             if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1673.                                 $count++;
  1674.                                 if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1675.                                     if($schoolStudentAverage->getNote() < 999.0){
  1676.                                         $averages += $schoolStudentAverage->getNote();
  1677.                                         //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1678.                                         $coeffecient += 1;
  1679.                                     }
  1680.                                 }else {
  1681.                                     if($schoolStudentAverage->getNote() < 999.0){
  1682.                                         //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getMatter()->getCoefficient();
  1683.                                         //$coeffecient += $schoolStudentAverage->getMatter()->getCoefficient();
  1684.                                         
  1685.                                         $averages += $schoolStudentAverage->getNote();
  1686.                                         $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1687.                                     }
  1688.                                 }
  1689.                             }
  1690.                         }
  1691.                     }
  1692.                 }
  1693.             }
  1694.             
  1695.             if ($coeffecient > 0) {
  1696.                 $periodeAverage = $averages / $coeffecient;
  1697.             }else {
  1698.                 $periodeAverage = 999;
  1699.             }
  1701.             return $periodeAverage;
  1702.         }
  1703.     }
  1705.     public function computeSubPeriodeAverage(SchoolSubMatter $schoolSubMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1706.         $averages = 0;
  1707.         $periodeAverage = 0;
  1708.         $count = 0;
  1709.         $coeffecient = 0;
  1710.         
  1711.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1712.             if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1713.                 $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1714.                 if (!$schoolStudentAverage->getIsUnclassified()) {
  1715.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1716.                         $count++;
  1717.                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1718.                             if($schoolStudentAverage->getNote() < 999){
  1719.                                 $averages += $schoolStudentAverage->getNote();
  1720.                                 //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1721.                                 $coeffecient += 1;
  1722.                             }
  1723.                         }else {
  1724.                             if($schoolStudentAverage->getNote() < 999){
  1725.                                 //$averages += $schoolStudentAverage->getNote() * $schoolSubMatter->getCoefficient();
  1726.                                 //$coeffecient += $schoolSubMatter->getCoefficient();
  1728.                                 $averages += $schoolStudentAverage->getNote();
  1729.                                 $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1730.                             }
  1731.                         }
  1732.                         
  1733.                     }
  1734.                 }
  1735.             }
  1736.         }
  1737.         
  1738.         if ($coeffecient > 0) {
  1739.             $periodeAverage = $averages / $coeffecient;
  1740.         }else {
  1741.             $periodeAverage = 999;
  1742.         }
  1744.         return $periodeAverage;
  1745.     }
  1747.     public function asMatterDone(SchoolMatter $schoolMatter, ReportCard $reportCard){
  1748.         
  1749.         $count = 0;
  1750.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1751.             if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1752.                 
  1753.                 $count++;
  1754.             }
  1755.         }
  1757.         return $count > 0;
  1758.     }
  1760.     public function getAnnualAverage(): ?float
  1761.     {
  1762.         $annual_average = 0;
  1763.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1764.             $annual_average = $schoolReportCard->getAnnualAverage();
  1765.         }
  1766.         return $annual_average;
  1767.     }
  1769.     public function getAnnualRank(): ?string
  1770.     {
  1771.         $annual_rank = 0;
  1772.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1773.             $annual_rank = $schoolReportCard->getAnnualRank();
  1774.         }
  1775.         return $annual_rank;
  1776.     }
  1778.     /**
  1779.      * @return Collection|NurseryTimeSheet[]
  1780.      */
  1781.     public function getNurseryTimeSheets(): Collection
  1782.     {
  1783.         return $this->nurseryTimeSheets;
  1784.     }
  1786.     public function addNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1787.     {
  1788.         if (!$this->nurseryTimeSheets->contains($nurseryTimeSheet)) {
  1789.             $this->nurseryTimeSheets[] = $nurseryTimeSheet;
  1790.             $nurseryTimeSheet->setRegistrationStudentRegistration($this);
  1791.         }
  1793.         return $this;
  1794.     }
  1796.     public function removeNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1797.     {
  1798.         if ($this->nurseryTimeSheets->removeElement($nurseryTimeSheet)) {
  1799.             // set the owning side to null (unless already changed)
  1800.             if ($nurseryTimeSheet->getRegistrationStudentRegistration() === $this) {
  1801.                 $nurseryTimeSheet->setRegistrationStudentRegistration(null);
  1802.             }
  1803.         }
  1805.         return $this;
  1806.     }
  1808.     /**
  1809.      * @return Collection|SchoolTeacherCallSheetLine[]
  1810.      */
  1811.     public function getSchoolTeacherCallSheetLines(): Collection
  1812.     {
  1813.         return $this->schoolTeacherCallSheetLines;
  1814.     }
  1816.     public function addSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1817.     {
  1818.         if (!$this->schoolTeacherCallSheetLines->contains($schoolTeacherCallSheetLine)) {
  1819.             $this->schoolTeacherCallSheetLines[] = $schoolTeacherCallSheetLine;
  1820.             $schoolTeacherCallSheetLine->setRegistrationStudentRegistration($this);
  1821.         }
  1823.         return $this;
  1824.     }
  1826.     public function removeSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1827.     {
  1828.         if ($this->schoolTeacherCallSheetLines->removeElement($schoolTeacherCallSheetLine)) {
  1829.             // set the owning side to null (unless already changed)
  1830.             if ($schoolTeacherCallSheetLine->getRegistrationStudentRegistration() === $this) {
  1831.                 $schoolTeacherCallSheetLine->setRegistrationStudentRegistration(null);
  1832.             }
  1833.         }
  1835.         return $this;
  1836.     }
  1838.     public function getJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1839.         $minute = 0;
  1840.         $heure = 0;
  1841.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1842.             if ($schoolAbsenceAndDelay->getIsJustify()) {
  1843.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1844.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1845.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1846.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1847.                         }
  1849.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1850.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1851.                         }
  1852.                     }
  1853.                 }
  1854.             }
  1855.         }
  1857.         $heure = ceil($heure + ($minute / 60));
  1858.         
  1859.         return $heure;
  1860.     }
  1862.     public function getNotJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1863.         $minute = 0;
  1864.         $heure = 0;
  1865.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1866.             if (!$schoolAbsenceAndDelay->getIsJustify()) {
  1867.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1868.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1869.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1870.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1871.                         }
  1873.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1874.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1875.                         }
  1876.                     }
  1877.                 }
  1878.             }
  1879.         }
  1881.         $heure = ceil($heure + ($minute / 60));
  1882.         
  1883.         return $heure;
  1884.     }
  1886.     public function isReported(){
  1887.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1888.             if ($accountingStudentRegistrationFee->getIsReported()) {
  1889.                 return true;
  1890.                 break;
  1891.             }
  1892.         }
  1894.         return false;
  1895.     }
  1897.     public function getNurseryPresence(DateTimeImmutable $startDate, DateTimeImmutable $endDate){
  1898.         
  1899.         $data = new ArrayCollection();
  1900.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1901.             if ($startDate <= $schoolTeacherCallSheetLine->getCreateDate() && $schoolTeacherCallSheetLine->getCreateDate() <= $endDate) {
  1902.                 $data->add($schoolTeacherCallSheetLine);
  1903.             }
  1904.         }
  1906.         return $data;
  1907.     }
  1909.     /**
  1910.      * @return Collection|AccountingChequeTrackingLine[]
  1911.      */
  1912.     public function getAccountingChequeTrackingLines(): Collection
  1913.     {
  1914.         return $this->accountingChequeTrackingLines;
  1915.     }
  1917.     public function addAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1918.     {
  1919.         if (!$this->accountingChequeTrackingLines->contains($accountingChequeTrackingLine)) {
  1920.             $this->accountingChequeTrackingLines[] = $accountingChequeTrackingLine;
  1921.             $accountingChequeTrackingLine->setRegistrationStudentRegistration($this);
  1922.         }
  1924.         return $this;
  1925.     }
  1927.     public function removeAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1928.     {
  1929.         if ($this->accountingChequeTrackingLines->removeElement($accountingChequeTrackingLine)) {
  1930.             // set the owning side to null (unless already changed)
  1931.             if ($accountingChequeTrackingLine->getRegistrationStudentRegistration() === $this) {
  1932.                 $accountingChequeTrackingLine->setRegistrationStudentRegistration(null);
  1933.             }
  1934.         }
  1936.         return $this;
  1937.     }
  1939.     public function getAbsenceStatus($day){
  1940.         $nb = 0;
  1941.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1942.             //if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getSchoolTeacherCallSheet()->getSettingTimeTable() == $settingTimeTable) {
  1943.             if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getIsAbsent()) {
  1944.                 $nb++;
  1945.             }
  1946.         }
  1948.         return $nb;
  1949.     }
  1951.     /**
  1952.      * @return Collection|SchoolReportCardAbsence[]
  1953.      */
  1954.     public function getSchoolReportCardAbsences(): Collection
  1955.     {
  1956.         return $this->schoolReportCardAbsences;
  1957.     }
  1959.     public function addSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1960.     {
  1961.         if (!$this->schoolReportCardAbsences->contains($schoolReportCardAbsence)) {
  1962.             $this->schoolReportCardAbsences[] = $schoolReportCardAbsence;
  1963.             $schoolReportCardAbsence->setStudentRegistration($this);
  1964.         }
  1966.         return $this;
  1967.     }
  1969.     public function removeSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1970.     {
  1971.         if ($this->schoolReportCardAbsences->removeElement($schoolReportCardAbsence)) {
  1972.             // set the owning side to null (unless already changed)
  1973.             if ($schoolReportCardAbsence->getStudentRegistration() === $this) {
  1974.                 $schoolReportCardAbsence->setStudentRegistration(null);
  1975.             }
  1976.         }
  1978.         return $this;
  1979.     }
  1981.     /**
  1982.      * @return Collection|WavePayment[]
  1983.      */
  1984.     public function getWavePayments(): Collection
  1985.     {
  1986.         return $this->wavePayments;
  1987.     }
  1989.     public function addWavePayment(WavePayment $wavePayment): self
  1990.     {
  1991.         if (!$this->wavePayments->contains($wavePayment)) {
  1992.             $this->wavePayments[] = $wavePayment;
  1993.             $wavePayment->setStudentRegistration($this);
  1994.         }
  1996.         return $this;
  1997.     }
  1999.     public function removeWavePayment(WavePayment $wavePayment): self
  2000.     {
  2001.         if ($this->wavePayments->removeElement($wavePayment)) {
  2002.             // set the owning side to null (unless already changed)
  2003.             if ($wavePayment->getStudentRegistration() === $this) {
  2004.                 $wavePayment->setStudentRegistration(null);
  2005.             }
  2006.         }
  2008.         return $this;
  2009.     }
  2011.     public function getSchoolAverage(SchoolAverage $schoolAverage){
  2012.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2013.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2014.                 return $schoolStudentAverage->getNote();
  2015.             }
  2016.         }
  2018.         return false;
  2019.     }
  2021.    
  2023.     public function getSchoolAverageSub(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2024.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2025.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2026.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2027.                     return $schoolStudentAverage->getNote();
  2028.                 }
  2029.             }
  2030.         }
  2032.         return false;
  2033.     }
  2035.     public function getSchoolAverageMaterLabel(SchoolAverage $schoolAverage){
  2036.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2037.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2038.                 if ($schoolStudentAverage->getSubMatter()) {
  2039.                     return $schoolStudentAverage->getSubMatter()->getCode();
  2040.                 }
  2041.                 
  2042.             }
  2043.         }
  2045.         return false;
  2046.     }
  2048.     public function getSchoolAverageCoeff(SchoolAverage $schoolAverage){
  2049.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2050.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2051.                 return $schoolStudentAverage->getCoefficient();
  2052.             }
  2053.         }
  2055.         return false;
  2056.     }
  2058.     public function getSchoolSubAverageCoeff(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2059.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2060.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2061.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2062.                     return $schoolStudentAverage->getCoefficient();
  2063.                 }
  2064.             }
  2065.         }
  2067.         return false;
  2068.     }
  2070.     public function average_report_card(SchoolYearPeriode $schoolYearPeriode, SchoolMatter $schoolMatter){
  2071.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2072.             if ($schoolAverageReportCard->getMatter() == $schoolMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2073.                 return $schoolAverageReportCard;
  2074.             }
  2075.         }
  2077.         return new SchoolAverageReportCard();
  2078.     }
  2080.     public function average_report_card_sub(SchoolYearPeriode $schoolYearPeriode, SchoolSubMatter $schoolSubMatter){
  2081.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2082.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2083.                 return $schoolAverageReportCard;
  2084.             }
  2085.         }
  2087.         return new SchoolAverageReportCard();
  2088.     }
  2090.     public function annual_average_report_card(SchoolMatter $schoolMatter){
  2091.         $averageReportCard = new SchoolAverageReportCard();
  2092.         
  2093.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2094.             if ($schoolAverageReportCard->getMatter() == $schoolMatter) {
  2095.                 $averageReportCard = $schoolAverageReportCard;
  2096.             }
  2097.         }
  2099.         return $averageReportCard;
  2100.     }
  2102.     public function annual_average_report_card_sub(SchoolSubMatter $schoolSubMatter){
  2103.         $averageReportCard = new SchoolAverageReportCard();
  2105.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2106.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2107.                 $averageReportCard = $schoolAverageReportCard;
  2108.             }
  2109.         }
  2111.         return $averageReportCard;
  2112.     }
  2114.     public function last_report_card(){
  2115.         $reportCard = new SchoolReportCard();
  2117.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  2118.             //if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2119.                 $reportCard = $schoolReportCard;
  2120.             //}
  2121.         }
  2123.         return $reportCard;
  2124.     }
  2126.     public function average_report_card_type(SchoolYearPeriode $schoolYearPeriode, SchoolMatterType $schoolMatterType){
  2127.         $sCoeff = 0;
  2128.         $sXCoeff = 0;
  2129.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2130.             if ($schoolAverageReportCard->getMatter()->getMatterType() == $schoolMatterType && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2131.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2132.                 $sCoeff += $schoolAverageReportCard->getCoefficient();
  2133.             }
  2134.         }
  2136.         if ($sCoeff > 0) {
  2137.             return ($sXCoeff / $sCoeff);
  2138.         }
  2140.         return 0;
  2141.     }
  2143.     public function total_xaverage_report_card(SchoolYearPeriode $schoolYearPeriode){
  2144.         $sXCoeff = 0;
  2145.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2146.             if ($schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2147.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2148.             }
  2149.         }
  2151.         return $sXCoeff;
  2152.     }
  2154.     /**
  2155.      * @return Collection|RegistrationStudentContact[]
  2156.      */
  2157.     public function getRegistrationStudentContacts(): Collection
  2158.     {
  2159.         return $this->registrationStudentContacts;
  2160.     }
  2162.     public function addRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2163.     {
  2164.         if (!$this->registrationStudentContacts->contains($registrationStudentContact)) {
  2165.             $this->registrationStudentContacts[] = $registrationStudentContact;
  2166.             $registrationStudentContact->setRegistrationStudentRegistration($this);
  2167.         }
  2169.         return $this;
  2170.     }
  2172.     public function removeRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2173.     {
  2174.         if ($this->registrationStudentContacts->removeElement($registrationStudentContact)) {
  2175.             // set the owning side to null (unless already changed)
  2176.             if ($registrationStudentContact->getRegistrationStudentRegistration() === $this) {
  2177.                 $registrationStudentContact->setRegistrationStudentRegistration(null);
  2178.             }
  2179.         }
  2181.         return $this;
  2182.     }
  2184.     /**
  2185.      * @return Collection|TransportCallSheetLine[]
  2186.      */
  2187.     public function getTransportCallSheetLines(): Collection
  2188.     {
  2189.         return $this->transportCallSheetLines;
  2190.     }
  2192.     public function addTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2193.     {
  2194.         if (!$this->transportCallSheetLines->contains($transportCallSheetLine)) {
  2195.             $this->transportCallSheetLines[] = $transportCallSheetLine;
  2196.             $transportCallSheetLine->setRegistrationStudentRegistration($this);
  2197.         }
  2199.         return $this;
  2200.     }
  2202.     public function removeTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2203.     {
  2204.         if ($this->transportCallSheetLines->removeElement($transportCallSheetLine)) {
  2205.             // set the owning side to null (unless already changed)
  2206.             if ($transportCallSheetLine->getRegistrationStudentRegistration() === $this) {
  2207.                 $transportCallSheetLine->setRegistrationStudentRegistration(null);
  2208.             }
  2209.         }
  2211.         return $this;
  2212.     }
  2214.     /**
  2215.      * @return Collection|StockExitSlip[]
  2216.      */
  2217.     public function getStockExitSlips(): Collection
  2218.     {
  2219.         return $this->stockExitSlips;
  2220.     }
  2222.     public function addStockExitSlip(StockExitSlip $stockExitSlip): self
  2223.     {
  2224.         if (!$this->stockExitSlips->contains($stockExitSlip)) {
  2225.             $this->stockExitSlips[] = $stockExitSlip;
  2226.             $stockExitSlip->setRegistrationStudentRegistration($this);
  2227.         }
  2229.         return $this;
  2230.     }
  2232.     public function removeStockExitSlip(StockExitSlip $stockExitSlip): self
  2233.     {
  2234.         if ($this->stockExitSlips->removeElement($stockExitSlip)) {
  2235.             // set the owning side to null (unless already changed)
  2236.             if ($stockExitSlip->getRegistrationStudentRegistration() === $this) {
  2237.                 $stockExitSlip->setRegistrationStudentRegistration(null);
  2238.             }
  2239.         }
  2241.         return $this;
  2242.     }
  2244.     public function getTotalSchooling(){
  2245.         $total = 0;
  2247.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2248.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2249.                 $total += $accountingStudentRegistrationFee->getAmount();
  2250.             }
  2251.         }
  2253.         return $total;
  2254.     }
  2256.     public function getSchooling(){
  2257.         $data = new ArrayCollection();
  2259.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2260.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2261.                 $data->add($accountingStudentRegistrationFee);
  2262.             }
  2263.         }
  2265.         return $data;
  2266.     }
  2268.     public function getFirstPayment(){
  2269.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  2270.             return $accountingStudentRegistrationPayment->getAmount();
  2271.         }
  2273.         return 0;
  2274.     }
  2275. }