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.     public function __construct()
  315.     {
  316.         $this->accountingStudentRegistrationFees = new ArrayCollection();
  317.         $this->schoolReportCards = new ArrayCollection();
  318.         $this->schoolAverageReportCards = new ArrayCollection();
  319.         $this->schoolAssessmentByClasses = new ArrayCollection();
  320.         $this->schoolAssessmentByLevels = new ArrayCollection();
  321.         $this->schoolAssessmentByClassByMatters = new ArrayCollection();
  322.         $this->schoolAssessmentByLevelByMatters = new ArrayCollection();
  323.         $this->is_affected = false;
  324.         $this->is_diet = false;
  325.         $this->is_internal = true;
  326.         $this->is_redoubling = false;
  327.         $this->is_abandonned = false;
  328.         $this->registered_at = new DateTimeImmutable();
  329.         $this->accountingStudentRegistrationPayments = new ArrayCollection();
  330.         $this->registrationClassChanges = new ArrayCollection();
  331.         $this->registrationStudentDowngrades = new ArrayCollection();
  332.         $this->registrationStudentAbandonments = new ArrayCollection();
  333.         $this->registrationTransportCheckpoints = new ArrayCollection();
  335.         $this->as_food_restrictions = false;
  336.         $this->is_meatless_menu = false;
  337.         $this->is_menu_without_pork = false;
  338.         $this->is_can_eat_alone = true;
  339.         $this->is_can_do_his_business_alone = true;
  340.         $this->is_falls_sleep_easily = false;
  341.         $this->schoolAbsenceAndDelays = new ArrayCollection();
  342.         $this->documentProvides = new ArrayCollection();
  343.         $this->communicationMessages = new ArrayCollection();
  345.         $this->is_new = false;
  346.         $this->stockStudentKitEntries = new ArrayCollection();
  347.         $this->stockKitOuts = new ArrayCollection();
  348.         $this->accountingCredits = new ArrayCollection();
  349.         $this->schoolStudentAverages = new ArrayCollection();
  350.         $this->nurseryTimeSheets = new ArrayCollection();
  351.         $this->schoolTeacherCallSheetLines = new ArrayCollection();
  352.         $this->accountingChequeTrackingLines = new ArrayCollection();
  353.         $this->schoolReportCardAbsences = new ArrayCollection();
  354.         $this->wavePayments = new ArrayCollection();
  355.     }
  357.     public function getName()
  358.     {
  359.         return $this->getStudent()->getName();
  360.     }
  362.     public function __toString()
  363.     {
  364.         return $this->getName().' ['.$this->getClassroom()->getLabel().']'.' ['.$this->getStudent()->getRegistrationNumber().']';
  365.     }
  367.     /**
  368.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  369.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  370.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  371.      * must be able to accept an instance of 'File' as the bundle will inject one here
  372.      * during Doctrine hydration.
  373.      *
  374.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  375.      */
  376.     public function setImageFile(?File $imageFile = null): void
  377.     {
  378.         $this->imageFile = $imageFile;
  380.         if (null !== $imageFile) {
  381.             // It is required that at least one field changes if you are using doctrine
  382.             // otherwise the event listeners won't be called and the file is lost
  383.             $this->updated_at = new \DateTimeImmutable();
  384.         }
  385.     }
  387.     public function getImageFile(): ?File
  388.     {
  389.         return $this->imageFile;
  390.     }
  392.     public function getId(): ?int
  393.     {
  394.         return $this->id;
  395.     }
  397.     public function getEstablishment(): ?Establishment
  398.     {
  399.         return $this->establishment;
  400.     }
  402.     public function setEstablishment(?Establishment $establishment): self
  403.     {
  404.         $this->establishment = $establishment;
  406.         return $this;
  407.     }
  409.     public function getStudent(): ?RegistrationStudent
  410.     {
  411.         return $this->student;
  412.     }
  414.     public function setStudent(?RegistrationStudent $student): self
  415.     {
  416.         $this->student = $student;
  418.         return $this;
  419.     }
  421.     public function getSchoolYear(): ?SchoolYear
  422.     {
  423.         return $this->schoolYear;
  424.     }
  426.     public function setSchoolYear(?SchoolYear $schoolYear): self
  427.     {
  428.         $this->schoolYear = $schoolYear;
  430.         return $this;
  431.     }
  433.     public function getClassroom(): ?SettingClassroom
  434.     {
  435.         return $this->classroom;
  436.     }
  438.     public function setClassroom(?SettingClassroom $classroom): self
  439.     {
  440.         $this->classroom = $classroom;
  442.         return $this;
  443.     }
  445.     public function getCreatedAt(): ?\DateTimeImmutable
  446.     {
  447.         return $this->created_at;
  448.     }
  450.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  451.     {
  452.         $this->created_at = $created_at;
  454.         return $this;
  455.     }
  457.     public function getUpdatedAt(): ?\DateTimeImmutable
  458.     {
  459.         return $this->updated_at;
  460.     }
  462.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  463.     {
  464.         $this->updated_at = $updated_at;
  466.         return $this;
  467.     }
  469.     public function getCreatedBy(): ?int
  470.     {
  471.         return $this->created_by;
  472.     }
  474.     public function setCreatedBy(int $created_by): self
  475.     {
  476.         $this->created_by = $created_by;
  478.         return $this;
  479.     }
  481.     public function getUpdatedBy(): ?int
  482.     {
  483.         return $this->updated_by;
  484.     }
  486.     public function setUpdatedBy(int $updated_by): self
  487.     {
  488.         $this->updated_by = $updated_by;
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return Collection|AccountingStudentRegistrationFee[]
  495.      */
  496.     public function getAccountingStudentRegistrationFees(): Collection
  497.     {
  498.         return $this->accountingStudentRegistrationFees;
  499.     }
  501.     public function addAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  502.     {
  503.         if (!$this->accountingStudentRegistrationFees->contains($accountingStudentRegistrationFee)) {
  504.             $this->accountingStudentRegistrationFees[] = $accountingStudentRegistrationFee;
  505.             $accountingStudentRegistrationFee->setStudentRegistration($this);
  506.         }
  508.         return $this;
  509.     }
  511.     public function removeAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  512.     {
  513.         if ($this->accountingStudentRegistrationFees->removeElement($accountingStudentRegistrationFee)) {
  514.             // set the owning side to null (unless already changed)
  515.             if ($accountingStudentRegistrationFee->getStudentRegistration() === $this) {
  516.                 $accountingStudentRegistrationFee->setStudentRegistration(null);
  517.             }
  518.         }
  520.         return $this;
  521.     }
  523.     /**
  524.      * @return Collection|SchoolReportCard[]
  525.      */
  526.     public function getSchoolReportCards(): Collection
  527.     {
  528.         return $this->schoolReportCards;
  529.     }
  531.     public function addSchoolReportCard(SchoolReportCard $schoolReportCard): self
  532.     {
  533.         if (!$this->schoolReportCards->contains($schoolReportCard)) {
  534.             $this->schoolReportCards[] = $schoolReportCard;
  535.             $schoolReportCard->setStudentRegistration($this);
  536.         }
  538.         return $this;
  539.     }
  541.    
  542.     public function getOrderedSchoolReportCards(SchoolReportCardRepository $schoolReportCardRepository)
  543.     {
  544.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  545.         ->innerJoin('entity.schoolYearPeriode', 'schoolYearPeriode')
  546.         ->addSelect('schoolYearPeriode')
  548.         ->andWhere('entity.studentRegistration = :studentRegistration')
  549.         ->setParameter('studentRegistration', $this)
  551.         ->orderBy('schoolYearPeriode.code', 'ASC')
  552.         ->getQuery()
  553.         ->getResult();
  555.         return $schoolReportCards;
  556.     }
  558.     public function removeSchoolReportCard(SchoolReportCard $schoolReportCard): self
  559.     {
  560.         if ($this->schoolReportCards->removeElement($schoolReportCard)) {
  561.             // set the owning side to null (unless already changed)
  562.             if ($schoolReportCard->getStudentRegistration() === $this) {
  563.                 $schoolReportCard->setStudentRegistration(null);
  564.             }
  565.         }
  567.         return $this;
  568.     }
  570.     /**
  571.      * @return Collection|SchoolAverageReportCard[]
  572.      */
  573.     public function getSchoolAverageReportCards(): Collection
  574.     {
  575.         return $this->schoolAverageReportCards;
  576.     }
  578.     public function addSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  579.     {
  580.         if (!$this->schoolAverageReportCards->contains($schoolAverageReportCard)) {
  581.             $this->schoolAverageReportCards[] = $schoolAverageReportCard;
  582.             $schoolAverageReportCard->setStudentRegistration($this);
  583.         }
  585.         return $this;
  586.     }
  588.     public function removeSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  589.     {
  590.         if ($this->schoolAverageReportCards->removeElement($schoolAverageReportCard)) {
  591.             // set the owning side to null (unless already changed)
  592.             if ($schoolAverageReportCard->getStudentRegistration() === $this) {
  593.                 $schoolAverageReportCard->setStudentRegistration(null);
  594.             }
  595.         }
  597.         return $this;
  598.     }
  600.     /**
  601.      * @return Collection|SchoolAssessmentByClass[]
  602.      */
  603.     public function getSchoolAssessmentByClasses(): Collection
  604.     {
  605.         return $this->schoolAssessmentByClasses;
  606.     }
  608.     public function addSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  609.     {
  610.         if (!$this->schoolAssessmentByClasses->contains($schoolAssessmentByClass)) {
  611.             $this->schoolAssessmentByClasses[] = $schoolAssessmentByClass;
  612.             $schoolAssessmentByClass->setStudentRegistration($this);
  613.         }
  615.         return $this;
  616.     }
  618.     public function removeSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  619.     {
  620.         if ($this->schoolAssessmentByClasses->removeElement($schoolAssessmentByClass)) {
  621.             // set the owning side to null (unless already changed)
  622.             if ($schoolAssessmentByClass->getStudentRegistration() === $this) {
  623.                 $schoolAssessmentByClass->setStudentRegistration(null);
  624.             }
  625.         }
  627.         return $this;
  628.     }
  630.     /**
  631.      * @return Collection|SchoolAssessmentByLevel[]
  632.      */
  633.     public function getSchoolAssessmentByLevels(): Collection
  634.     {
  635.         return $this->schoolAssessmentByLevels;
  636.     }
  638.     public function addSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  639.     {
  640.         if (!$this->schoolAssessmentByLevels->contains($schoolAssessmentByLevel)) {
  641.             $this->schoolAssessmentByLevels[] = $schoolAssessmentByLevel;
  642.             $schoolAssessmentByLevel->setStudentRegistration($this);
  643.         }
  645.         return $this;
  646.     }
  648.     public function removeSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  649.     {
  650.         if ($this->schoolAssessmentByLevels->removeElement($schoolAssessmentByLevel)) {
  651.             // set the owning side to null (unless already changed)
  652.             if ($schoolAssessmentByLevel->getStudentRegistration() === $this) {
  653.                 $schoolAssessmentByLevel->setStudentRegistration(null);
  654.             }
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * @return Collection|SchoolAssessmentByClassByMatter[]
  662.      */
  663.     public function getSchoolAssessmentByClassByMatters(): Collection
  664.     {
  665.         return $this->schoolAssessmentByClassByMatters;
  666.     }
  668.     public function addSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  669.     {
  670.         if (!$this->schoolAssessmentByClassByMatters->contains($schoolAssessmentByClassByMatter)) {
  671.             $this->schoolAssessmentByClassByMatters[] = $schoolAssessmentByClassByMatter;
  672.             $schoolAssessmentByClassByMatter->setStudentRegistration($this);
  673.         }
  675.         return $this;
  676.     }
  678.     public function removeSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  679.     {
  680.         if ($this->schoolAssessmentByClassByMatters->removeElement($schoolAssessmentByClassByMatter)) {
  681.             // set the owning side to null (unless already changed)
  682.             if ($schoolAssessmentByClassByMatter->getStudentRegistration() === $this) {
  683.                 $schoolAssessmentByClassByMatter->setStudentRegistration(null);
  684.             }
  685.         }
  687.         return $this;
  688.     }
  690.     /**
  691.      * @return Collection|SchoolAssessmentByLevelByMatter[]
  692.      */
  693.     public function getSchoolAssessmentByLevelByMatters(): Collection
  694.     {
  695.         return $this->schoolAssessmentByLevelByMatters;
  696.     }
  698.     public function addSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  699.     {
  700.         if (!$this->schoolAssessmentByLevelByMatters->contains($schoolAssessmentByLevelByMatter)) {
  701.             $this->schoolAssessmentByLevelByMatters[] = $schoolAssessmentByLevelByMatter;
  702.             $schoolAssessmentByLevelByMatter->setStudentRegistration($this);
  703.         }
  705.         return $this;
  706.     }
  708.     public function removeSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  709.     {
  710.         if ($this->schoolAssessmentByLevelByMatters->removeElement($schoolAssessmentByLevelByMatter)) {
  711.             // set the owning side to null (unless already changed)
  712.             if ($schoolAssessmentByLevelByMatter->getStudentRegistration() === $this) {
  713.                 $schoolAssessmentByLevelByMatter->setStudentRegistration(null);
  714.             }
  715.         }
  717.         return $this;
  718.     }
  720.     public function getIsRedoubling(): ?bool
  721.     {
  722.         return $this->is_redoubling;
  723.     }
  725.     public function setIsRedoubling(bool $is_redoubling): self
  726.     {
  727.         $this->is_redoubling = $is_redoubling;
  729.         return $this;
  730.     }
  732.     public function getIsDiet(): ?bool
  733.     {
  734.         return $this->is_diet;
  735.     }
  737.     public function setIsDiet(bool $is_diet): self
  738.     {
  739.         $this->is_diet = $is_diet;
  741.         return $this;
  742.     }
  744.     public function getIsInternal(): ?bool
  745.     {
  746.         return $this->is_internal;
  747.     }
  749.     public function setIsInternal(bool $is_internal): self
  750.     {
  751.         $this->is_internal = $is_internal;
  753.         return $this;
  754.     }
  756.     public function getIsAffected(): ?bool
  757.     {
  758.         return $this->is_affected;
  759.     }
  761.     public function setIsAffected(bool $is_affected): self
  762.     {
  763.         $this->is_affected = $is_affected;
  765.         return $this;
  766.     }
  768.     public function getRegisteredAt(): ?\DateTimeImmutable
  769.     {
  770.         return $this->registered_at;
  771.     }
  773.     public function setRegisteredAt(\DateTimeImmutable $registered_at): self
  774.     {
  775.         $this->registered_at = $registered_at;
  777.         return $this;
  778.     }
  780.     public function getGleAmount(){
  781.         $amount = 0;
  782.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $fee) {
  783.             if (!$fee->getIsArchived()) {
  784.                 $amount = $amount + $fee->getAmount();
  785.             }
  786.         }
  788.         return $amount;
  789.     }
  791.     public function getAmountPaid(){
  792.         $amount = 0;
  793.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  794.             $amount = $amount + $accountingStudentRegistrationPayment->getAmount();
  795.         }
  797.         $payArchived = 0;
  798.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  799.             if ($accountingStudentRegistrationFee->getIsArchived()) {
  800.                 $payArchived = $payArchived + $accountingStudentRegistrationFee->getAmountPaid();
  801.             }
  802.             
  803.         }
  806.         return $amount - $payArchived;
  807.     }
  809.     public function getAmountCancel(): ?float
  810.     {
  811.         $amountCancel = 0;
  812.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  813.             //if (!$accountingStudentRegistrationFee->getIsArchived()) {
  814.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountReported();
  815.             //}
  816.         }
  817.         
  818.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  819.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  820.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountCancel();
  821.             }
  822.         }
  823.         
  824.         return $amountCancel;
  825.     }
  827.     public function getAmountRest(): ?float
  828.     {
  829.         return ($this->getGleAmount() - ($this->getAmountPaid() + $this->getAmountCancel()));
  830.     }
  832.     /**
  833.      * @return Collection|AccountingStudentRegistrationPayment[]
  834.      */
  835.     public function getAccountingStudentRegistrationPayments(): Collection
  836.     {
  837.         return $this->accountingStudentRegistrationPayments;
  838.     }
  840.     public function addAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  841.     {
  842.         if (!$this->accountingStudentRegistrationPayments->contains($accountingStudentRegistrationPayment)) {
  843.             $this->accountingStudentRegistrationPayments[] = $accountingStudentRegistrationPayment;
  844.             $accountingStudentRegistrationPayment->setStudentRegistration($this);
  845.         }
  847.         return $this;
  848.     }
  850.     public function removeAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  851.     {
  852.         if ($this->accountingStudentRegistrationPayments->removeElement($accountingStudentRegistrationPayment)) {
  853.             // set the owning side to null (unless already changed)
  854.             if ($accountingStudentRegistrationPayment->getStudentRegistration() === $this) {
  855.                 $accountingStudentRegistrationPayment->setStudentRegistration(null);
  856.             }
  857.         }
  859.         return $this;
  860.     }
  862.     public function getLastAmountPaid(): ?float
  863.     {
  864.         return $this->last_amount_paid;
  865.     }
  867.     public function setLastAmountPaid(?float $last_amount_paid): self
  868.     {
  869.         $this->last_amount_paid = $last_amount_paid;
  871.         return $this;
  872.     }
  874.     public function getLastPaymentId(): ?int
  875.     {
  876.         return $this->last_payment_id;
  877.     }
  879.     public function setLastPaymentId(?int $last_payment_id): self
  880.     {
  881.         $this->last_payment_id = $last_payment_id;
  883.         return $this;
  884.     }
  886.     public function getLastPaymentAt(): ?\DateTimeImmutable
  887.     {
  888.         return $this->last_payment_at;
  889.     }
  891.     public function setLastPaymentAt(?\DateTimeImmutable $last_payment_at): self
  892.     {
  893.         $this->last_payment_at = $last_payment_at;
  895.         return $this;
  896.     }
  898.     public function getImage(): ?string
  899.     {
  900.         return $this->image;
  901.     }
  903.     public function setImage(?string $image): self
  904.     {
  905.         $this->image = $image;
  907.         return $this;
  908.     }
  910.     /**
  911.      * @return Collection|RegistrationClassChange[]
  912.      */
  913.     public function getRegistrationClassChanges(): Collection
  914.     {
  915.         return $this->registrationClassChanges;
  916.     }
  918.     public function addRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  919.     {
  920.         if (!$this->registrationClassChanges->contains($registrationClassChange)) {
  921.             $this->registrationClassChanges[] = $registrationClassChange;
  922.             $registrationClassChange->setStudentRegistration($this);
  923.         }
  925.         return $this;
  926.     }
  928.     public function removeRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  929.     {
  930.         if ($this->registrationClassChanges->removeElement($registrationClassChange)) {
  931.             // set the owning side to null (unless already changed)
  932.             if ($registrationClassChange->getStudentRegistration() === $this) {
  933.                 $registrationClassChange->setStudentRegistration(null);
  934.             }
  935.         }
  937.         return $this;
  938.     }
  940.     /**
  941.      * @return Collection|RegistrationStudentDowngrade[]
  942.      */
  943.     public function getRegistrationStudentDowngrades(): Collection
  944.     {
  945.         return $this->registrationStudentDowngrades;
  946.     }
  948.     public function addRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  949.     {
  950.         if (!$this->registrationStudentDowngrades->contains($registrationStudentDowngrade)) {
  951.             $this->registrationStudentDowngrades[] = $registrationStudentDowngrade;
  952.             $registrationStudentDowngrade->setRegistrationStudentRegistration($this);
  953.         }
  955.         return $this;
  956.     }
  958.     public function removeRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  959.     {
  960.         if ($this->registrationStudentDowngrades->removeElement($registrationStudentDowngrade)) {
  961.             // set the owning side to null (unless already changed)
  962.             if ($registrationStudentDowngrade->getRegistrationStudentRegistration() === $this) {
  963.                 $registrationStudentDowngrade->setRegistrationStudentRegistration(null);
  964.             }
  965.         }
  967.         return $this;
  968.     }
  970.     /**
  971.      * @return Collection|RegistrationStudentAbandonment[]
  972.      */
  973.     public function getRegistrationStudentAbandonments(): Collection
  974.     {
  975.         return $this->registrationStudentAbandonments;
  976.     }
  978.     public function addRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  979.     {
  980.         if (!$this->registrationStudentAbandonments->contains($registrationStudentAbandonment)) {
  981.             $this->registrationStudentAbandonments[] = $registrationStudentAbandonment;
  982.             $registrationStudentAbandonment->setRegistrationStudentRegistration($this);
  983.         }
  985.         return $this;
  986.     }
  988.     public function removeRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  989.     {
  990.         if ($this->registrationStudentAbandonments->removeElement($registrationStudentAbandonment)) {
  991.             // set the owning side to null (unless already changed)
  992.             if ($registrationStudentAbandonment->getRegistrationStudentRegistration() === $this) {
  993.                 $registrationStudentAbandonment->setRegistrationStudentRegistration(null);
  994.             }
  995.         }
  997.         return $this;
  998.     }
  1000.     public function getIsAbandonned(): ?bool
  1001.     {
  1002.         return $this->is_abandonned;
  1003.     }
  1005.     public function setIsAbandonned(bool $is_abandonned): self
  1006.     {
  1007.         $this->is_abandonned = $is_abandonned;
  1009.         return $this;
  1010.     }
  1012.     public function getRegistrationStudentPreRegistration(): ?RegistrationStudentPreRegistration
  1013.     {
  1014.         return $this->registrationStudentPreRegistration;
  1015.     }
  1017.     public function setRegistrationStudentPreRegistration(?RegistrationStudentPreRegistration $registrationStudentPreRegistration): self
  1018.     {
  1019.         $this->registrationStudentPreRegistration = $registrationStudentPreRegistration;
  1021.         return $this;
  1022.     }
  1024.     /**
  1025.      * @return Collection|RegistrationTransportCheckpoint[]
  1026.      */
  1027.     public function getRegistrationTransportCheckpoints(): Collection
  1028.     {
  1029.         return $this->registrationTransportCheckpoints;
  1030.     }
  1032.     public function addRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1033.     {
  1034.         if (!$this->registrationTransportCheckpoints->contains($registrationTransportCheckpoint)) {
  1035.             $this->registrationTransportCheckpoints[] = $registrationTransportCheckpoint;
  1036.             $registrationTransportCheckpoint->setRegistrationStudentRegistration($this);
  1037.         }
  1039.         return $this;
  1040.     }
  1042.     public function removeRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1043.     {
  1044.         if ($this->registrationTransportCheckpoints->removeElement($registrationTransportCheckpoint)) {
  1045.             // set the owning side to null (unless already changed)
  1046.             if ($registrationTransportCheckpoint->getRegistrationStudentRegistration() === $this) {
  1047.                 $registrationTransportCheckpoint->setRegistrationStudentRegistration(null);
  1048.             }
  1049.         }
  1051.         return $this;
  1052.     }
  1054.     public function hasTransportFee(){
  1055.         $reponse = false;
  1056.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1057.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::TRANSPORT_FEE && !$accountingStudentRegistrationFee->getIsCancel() && $accountingStudentRegistrationFee->getAmountPaid() > 0 && !$accountingStudentRegistrationFee->getIsArchived()) {
  1058.                 $reponse = true;
  1059.                 break;
  1060.             }
  1061.         }
  1063.         return $reponse;
  1064.     }
  1066.     public function hasGardeMidiFee(){
  1067.         $reponse = false;
  1068.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1069.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::GARDE_MIDI_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1070.                 $reponse = true;
  1071.                 break;
  1072.             }
  1073.         }
  1075.         return $reponse;
  1076.     }
  1078.     public function hasExtraFee(){
  1079.         $reponse = false;
  1080.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1081.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::ACTIVITE_EXTAT_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1082.                 $reponse = true;
  1083.                 break;
  1084.             }
  1085.         }
  1087.         return $reponse;
  1088.     }
  1090.     public function hasCanteenFee(){
  1091.         $reponse = false;
  1092.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1093.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::CANTINE_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1094.                 $reponse = true;
  1095.                 break;
  1096.             }
  1097.         }
  1099.         return $reponse;
  1100.     }
  1102.     public function hasMobileApp(){
  1103.         $reponse = false;
  1104.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1105.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::MOBILE_APP && !$accountingStudentRegistrationFee->getIsCancel()) {
  1106.                 $reponse = true;
  1107.                 break;
  1108.             }
  1109.         }
  1111.         return $reponse;
  1112.     }
  1114.     public function getAmountDueAt(DateTimeImmutable $dueDate, $category = '0'){
  1115.         
  1116.         $amountDue = 0;
  1117.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1118.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1119.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1120.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() >= 0) {
  1121.                         if ('0' != $category) {
  1122.                             if ($accountingStudentRegistrationFee->getFee()->getCategory() == $category) {
  1123.                                 $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1124.                             }
  1125.                         }else {
  1126.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1127.                         }
  1128.                     }
  1129.                 }
  1130.             }
  1131.         }
  1133.         $amountChequeTracking = 0;
  1134.         foreach ($this->getAccountingChequeTrackingLines() as $key => $accountingChequeTrackingLine) {
  1135.             if ($accountingChequeTrackingLine->getAccountingChequeTracking()->getStatus() == AccountingChequeTracking::EN_TRAITEMENT) {
  1136.                 $amountChequeTracking += $accountingChequeTrackingLine->getAmount();
  1137.             }
  1138.         }
  1139.         
  1140.         return $amountDue - $amountChequeTracking;
  1141.     }
  1143.     public function getAmountDueAtByFee(DateTimeImmutable $dueDate, SettingFee $settingFee){
  1144.         
  1145.         $amountDue = 0;
  1146.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1147.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1148.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1149.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1150.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1151.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1152.                         }
  1153.                     }
  1154.                 }
  1155.             }
  1156.         }
  1157.         
  1158.         return $amountDue;
  1159.     }
  1161.     public function getFeeShedulDues(DateTimeImmutable $dueDate){
  1162.         $feeShedulDues = new ArrayCollection();
  1163.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1164.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1165.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1166.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1167.                         $feeShedulDues->add($accountingStudentRegistrationFeeShedul);
  1168.                     }
  1169.                 }
  1170.             }
  1171.         }
  1172.         
  1173.         return $feeShedulDues;
  1174.     }
  1176.     public function getAsFoodRestrictions(): ?bool
  1177.     {
  1178.         return $this->as_food_restrictions;
  1179.     }
  1181.     public function setAsFoodRestrictions(bool $as_food_restrictions): self
  1182.     {
  1183.         $this->as_food_restrictions = $as_food_restrictions;
  1185.         return $this;
  1186.     }
  1188.     public function getIsMeatlessMenu(): ?bool
  1189.     {
  1190.         return $this->is_meatless_menu;
  1191.     }
  1193.     public function setIsMeatlessMenu(bool $is_meatless_menu): self
  1194.     {
  1195.         $this->is_meatless_menu = $is_meatless_menu;
  1197.         return $this;
  1198.     }
  1200.     public function getIsMenuWithoutPork(): ?bool
  1201.     {
  1202.         return $this->is_menu_without_pork;
  1203.     }
  1205.     public function setIsMenuWithoutPork(bool $is_menu_without_pork): self
  1206.     {
  1207.         $this->is_menu_without_pork = $is_menu_without_pork;
  1209.         return $this;
  1210.     }
  1212.     public function getIsCanEatAlone(): ?bool
  1213.     {
  1214.         return $this->is_can_eat_alone;
  1215.     }
  1217.     public function setIsCanEatAlone(bool $is_can_eat_alone): self
  1218.     {
  1219.         $this->is_can_eat_alone = $is_can_eat_alone;
  1221.         return $this;
  1222.     }
  1224.     public function getIsCanDoHisBusinessAlone(): ?bool
  1225.     {
  1226.         return $this->is_can_do_his_business_alone;
  1227.     }
  1229.     public function setIsCanDoHisBusinessAlone(bool $is_can_do_his_business_alone): self
  1230.     {
  1231.         $this->is_can_do_his_business_alone = $is_can_do_his_business_alone;
  1233.         return $this;
  1234.     }
  1236.     public function getIsFallsSleepEasily(): ?bool
  1237.     {
  1238.         return $this->is_falls_sleep_easily;
  1239.     }
  1241.     public function setIsFallsSleepEasily(bool $is_falls_sleep_easily): self
  1242.     {
  1243.         $this->is_falls_sleep_easily = $is_falls_sleep_easily;
  1245.         return $this;
  1246.     }
  1248.     /**
  1249.      * @return Collection|SchoolAbsenceAndDelay[]
  1250.      */
  1251.     public function getSchoolAbsenceAndDelays(): Collection
  1252.     {
  1253.         return $this->schoolAbsenceAndDelays;
  1254.     }
  1256.     public function addSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1257.     {
  1258.         if (!$this->schoolAbsenceAndDelays->contains($schoolAbsenceAndDelay)) {
  1259.             $this->schoolAbsenceAndDelays[] = $schoolAbsenceAndDelay;
  1260.             $schoolAbsenceAndDelay->setStudentRegistration($this);
  1261.         }
  1263.         return $this;
  1264.     }
  1266.     public function removeSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1267.     {
  1268.         if ($this->schoolAbsenceAndDelays->removeElement($schoolAbsenceAndDelay)) {
  1269.             // set the owning side to null (unless already changed)
  1270.             if ($schoolAbsenceAndDelay->getStudentRegistration() === $this) {
  1271.                 $schoolAbsenceAndDelay->setStudentRegistration(null);
  1272.             }
  1273.         }
  1275.         return $this;
  1276.     }
  1278.     public function getDelayByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1279.         $minute = 0;
  1280.         $heure = 0;
  1281.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1282.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1283.                 if ($schoolAbsenceAndDelay->getSituation() == 'RETARD') {
  1284.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1285.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1286.                     }
  1288.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1289.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1290.                     }
  1291.                 }
  1292.             }
  1293.         }
  1295.         $heure = ceil($heure + ($minute / 60));
  1296.         
  1297.         return $heure;
  1298.     }
  1300.     public function getAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1301.         $minute = 0;
  1302.         $heure = 0;
  1303.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1304.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1305.                 if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1306.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1307.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1308.                     }
  1310.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1311.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1312.                     }
  1313.                 }
  1314.             }
  1315.         }
  1317.         $heure = ceil($heure + ($minute / 60));
  1318.         
  1319.         return $heure;
  1320.     }
  1322.     /**
  1323.      * @return Collection|SettingDocumentToProvide[]
  1324.      */
  1325.     public function getDocumentProvides(): Collection
  1326.     {
  1327.         return $this->documentProvides;
  1328.     }
  1330.     public function addDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1331.     {
  1332.         if (!$this->documentProvides->contains($documentProvide)) {
  1333.             $this->documentProvides[] = $documentProvide;
  1334.         }
  1336.         return $this;
  1337.     }
  1339.     public function removeDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1340.     {
  1341.         $this->documentProvides->removeElement($documentProvide);
  1343.         return $this;
  1344.     }
  1346.     /**
  1347.      * @return Collection|CommunicationMessage[]
  1348.      */
  1349.     public function getCommunicationMessages(): Collection
  1350.     {
  1351.         return $this->communicationMessages;
  1352.     }
  1354.     public function addCommunicationMessage(CommunicationMessage $communicationMessage): self
  1355.     {
  1356.         if (!$this->communicationMessages->contains($communicationMessage)) {
  1357.             $this->communicationMessages[] = $communicationMessage;
  1358.             $communicationMessage->addStudentRegistration($this);
  1359.         }
  1361.         return $this;
  1362.     }
  1364.     public function removeCommunicationMessage(CommunicationMessage $communicationMessage): self
  1365.     {
  1366.         if ($this->communicationMessages->removeElement($communicationMessage)) {
  1367.             $communicationMessage->removeStudentRegistration($this);
  1368.         }
  1370.         return $this;
  1371.     }
  1373.     public function getIsNew(): ?bool
  1374.     {
  1375.         return $this->is_new;
  1376.     }
  1378.     public function setIsNew(bool $is_new): self
  1379.     {
  1380.         $this->is_new = $is_new;
  1382.         return $this;
  1383.     }
  1385.     /**
  1386.      * @return Collection|StockStudentKitEntry[]
  1387.      */
  1388.     public function getStockStudentKitEntries(): Collection
  1389.     {
  1390.         return $this->stockStudentKitEntries;
  1391.     }
  1393.     public function addStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1394.     {
  1395.         if (!$this->stockStudentKitEntries->contains($stockStudentKitEntry)) {
  1396.             $this->stockStudentKitEntries[] = $stockStudentKitEntry;
  1397.             $stockStudentKitEntry->setRegistrationStudent($this);
  1398.         }
  1400.         return $this;
  1401.     }
  1403.     public function removeStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1404.     {
  1405.         if ($this->stockStudentKitEntries->removeElement($stockStudentKitEntry)) {
  1406.             // set the owning side to null (unless already changed)
  1407.             if ($stockStudentKitEntry->getRegistrationStudent() === $this) {
  1408.                 $stockStudentKitEntry->setRegistrationStudent(null);
  1409.             }
  1410.         }
  1412.         return $this;
  1413.     }
  1415.     /**
  1416.      * @return Collection|StockKitOut[]
  1417.      */
  1418.     public function getStockKitOuts(): Collection
  1419.     {
  1420.         return $this->stockKitOuts;
  1421.     }
  1423.     public function addStockKitOut(StockKitOut $stockKitOut): self
  1424.     {
  1425.         if (!$this->stockKitOuts->contains($stockKitOut)) {
  1426.             $this->stockKitOuts[] = $stockKitOut;
  1427.             $stockKitOut->setRegistrationStudent($this);
  1428.         }
  1430.         return $this;
  1431.     }
  1433.     public function removeStockKitOut(StockKitOut $stockKitOut): self
  1434.     {
  1435.         if ($this->stockKitOuts->removeElement($stockKitOut)) {
  1436.             // set the owning side to null (unless already changed)
  1437.             if ($stockKitOut->getRegistrationStudent() === $this) {
  1438.                 $stockKitOut->setRegistrationStudent(null);
  1439.             }
  1440.         }
  1442.         return $this;
  1443.     }
  1445.     public function getPortalLogin(): ?string
  1446.     {
  1447.         return $this->portal_login;
  1448.     }
  1450.     public function setPortalLogin(?string $portal_login): self
  1451.     {
  1452.         $this->portal_login = $portal_login;
  1454.         return $this;
  1455.     }
  1457.     public function getPortalPassword(): ?string
  1458.     {
  1459.         return $this->portal_password;
  1460.     }
  1462.     public function setPortalPassword(?string $portal_password): self
  1463.     {
  1464.         $this->portal_password = $portal_password;
  1466.         return $this;
  1467.     }
  1469.     /**
  1470.      * @return Collection|AccountingCredit[]
  1471.      */
  1472.     public function getAccountingCredits(): Collection
  1473.     {
  1474.         return $this->accountingCredits;
  1475.     }
  1477.     public function addAccountingCredit(AccountingCredit $accountingCredit): self
  1478.     {
  1479.         if (!$this->accountingCredits->contains($accountingCredit)) {
  1480.             $this->accountingCredits[] = $accountingCredit;
  1481.             $accountingCredit->setStudentRegistration($this);
  1482.         }
  1484.         return $this;
  1485.     }
  1487.     public function removeAccountingCredit(AccountingCredit $accountingCredit): self
  1488.     {
  1489.         if ($this->accountingCredits->removeElement($accountingCredit)) {
  1490.             // set the owning side to null (unless already changed)
  1491.             if ($accountingCredit->getStudentRegistration() === $this) {
  1492.                 $accountingCredit->setStudentRegistration(null);
  1493.             }
  1494.         }
  1496.         return $this;
  1497.     }
  1499.     /**
  1500.      * @return Collection|SchoolStudentAverage[]
  1501.      */
  1502.     public function getSchoolStudentAverages(): Collection
  1503.     {
  1504.         return $this->schoolStudentAverages;
  1505.     }
  1507.     public function addSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1508.     {
  1509.         if (!$this->schoolStudentAverages->contains($schoolStudentAverage)) {
  1510.             $this->schoolStudentAverages[] = $schoolStudentAverage;
  1511.             $schoolStudentAverage->setRegistrationStudentRegistration($this);
  1512.         }
  1514.         return $this;
  1515.     }
  1517.     public function removeSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1518.     {
  1519.         if ($this->schoolStudentAverages->removeElement($schoolStudentAverage)) {
  1520.             // set the owning side to null (unless already changed)
  1521.             if ($schoolStudentAverage->getRegistrationStudentRegistration() === $this) {
  1522.                 $schoolStudentAverage->setRegistrationStudentRegistration(null);
  1523.             }
  1524.         }
  1526.         return $this;
  1527.     }
  1529.     public function computePeriodeAverage(SchoolMatter $schoolMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1530.         if (count($schoolMatter->getSchoolSubMatters()) > 0) {
  1531.             $averages = 0;
  1532.             $periodeAverage = 0;
  1533.             $count = 0;
  1534.             $coeffecient = 0;
  1535.             //foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1536.                 foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1537.                     if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1538.                         $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1539.                         if (!$schoolStudentAverage->getIsUnclassified()) {
  1540.                             if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1541.                                 if ($schoolStudentAverage->getSubMatter() != null) {
  1542.                                     if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1543.                                         $count ++;
  1544.                                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1545.                                             if($schoolStudentAverage->getNote() < 999){
  1546.                                                 $averages += $schoolStudentAverage->getNote();
  1547.                                                 $coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1548.                                             }
  1549.                                         }else {
  1550.                                             if($schoolStudentAverage->getNote() < 999){
  1551.                                                 $averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getSubMatter()->getCoefficient();
  1552.                                                 $coeffecient += $schoolStudentAverage->getSubMatter()->getCoefficient();
  1553.                                             }
  1554.                                         }
  1555.                                     }
  1556.                                 }
  1557.                             }
  1558.                         }
  1559.                     }
  1560.                 }
  1561.                 
  1562.                 if ($coeffecient > 0) {
  1563.                     $periodeAverage = $averages / $coeffecient;
  1564.                 }else {
  1565.                     $periodeAverage = 999;
  1566.                 }
  1568.                 return $periodeAverage;
  1569.             //}
  1570.         }else {
  1571.             $averages = 0;
  1572.             $periodeAverage = 0;
  1573.             $count = 0;
  1574.             $coeffecient = 0;
  1575.             foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1576.                 if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1577.                     $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1578.                     if (!$schoolStudentAverage->getIsUnclassified()) {
  1579.                         if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1580.                             $count++;
  1581.                             if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1582.                                 if($schoolStudentAverage->getNote() < 999){
  1583.                                     $averages += $schoolStudentAverage->getNote();
  1584.                                     $coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1585.                                 }
  1586.                             }else {
  1587.                                 if($schoolStudentAverage->getNote() < 999){
  1588.                                     $averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getMatter()->getCoefficient();
  1589.                                     $coeffecient += $schoolStudentAverage->getMatter()->getCoefficient();
  1590.                                 }
  1591.                             }
  1592.                         }
  1593.                     }
  1594.                 }
  1595.             }
  1596.             
  1597.             if ($coeffecient > 0) {
  1598.                 $periodeAverage = $averages / $coeffecient;
  1599.             }else {
  1600.                 $periodeAverage = 999;
  1601.             }
  1603.             return $periodeAverage;
  1604.         }
  1605.     }
  1607.     public function computeSubPeriodeAverage(SchoolSubMatter $schoolSubMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1608.         $averages = 0;
  1609.         $periodeAverage = 0;
  1610.         $count = 0;
  1611.         $coeffecient = 0;
  1612.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1613.             if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1614.                 $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1615.                 if (!$schoolStudentAverage->getIsUnclassified()) {
  1616.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1617.                         $count++;
  1618.                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1619.                             if($schoolStudentAverage->getNote() < 999){
  1620.                                 $averages += $schoolStudentAverage->getNote();
  1621.                                 $coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1622.                             }
  1623.                         }else {
  1624.                             if($schoolStudentAverage->getNote() < 999){
  1625.                                 $averages += $schoolStudentAverage->getNote() * $schoolSubMatter->getCoefficient();
  1626.                                 $coeffecient += $schoolSubMatter->getCoefficient();
  1627.                             }
  1628.                         }
  1629.                         
  1630.                     }
  1631.                 }
  1632.             }
  1633.         }
  1634.         
  1635.         if ($coeffecient > 0) {
  1636.             $periodeAverage = $averages / $coeffecient;
  1637.         }else {
  1638.             $periodeAverage = 999;
  1639.         }
  1641.         return $periodeAverage;
  1642.     }
  1644.     public function asMatterDone(SchoolMatter $schoolMatter, ReportCard $reportCard){
  1645.         
  1646.         $count = 0;
  1647.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1648.             if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1649.                 
  1650.                 $count++;
  1651.             }
  1652.         }
  1654.         return $count > 0;
  1655.     }
  1657.     public function getAnnualAverage(): ?float
  1658.     {
  1659.         $annual_average = 0;
  1660.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1661.             $annual_average = $schoolReportCard->getAnnualAverage();
  1662.         }
  1663.         return $annual_average;
  1664.     }
  1666.     public function getAnnualRank(): ?string
  1667.     {
  1668.         $annual_rank = 0;
  1669.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1670.             $annual_rank = $schoolReportCard->getAnnualRank();
  1671.         }
  1672.         return $annual_rank;
  1673.     }
  1675.     /**
  1676.      * @return Collection|NurseryTimeSheet[]
  1677.      */
  1678.     public function getNurseryTimeSheets(): Collection
  1679.     {
  1680.         return $this->nurseryTimeSheets;
  1681.     }
  1683.     public function addNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1684.     {
  1685.         if (!$this->nurseryTimeSheets->contains($nurseryTimeSheet)) {
  1686.             $this->nurseryTimeSheets[] = $nurseryTimeSheet;
  1687.             $nurseryTimeSheet->setRegistrationStudentRegistration($this);
  1688.         }
  1690.         return $this;
  1691.     }
  1693.     public function removeNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1694.     {
  1695.         if ($this->nurseryTimeSheets->removeElement($nurseryTimeSheet)) {
  1696.             // set the owning side to null (unless already changed)
  1697.             if ($nurseryTimeSheet->getRegistrationStudentRegistration() === $this) {
  1698.                 $nurseryTimeSheet->setRegistrationStudentRegistration(null);
  1699.             }
  1700.         }
  1702.         return $this;
  1703.     }
  1705.     /**
  1706.      * @return Collection|SchoolTeacherCallSheetLine[]
  1707.      */
  1708.     public function getSchoolTeacherCallSheetLines(): Collection
  1709.     {
  1710.         return $this->schoolTeacherCallSheetLines;
  1711.     }
  1713.     public function addSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1714.     {
  1715.         if (!$this->schoolTeacherCallSheetLines->contains($schoolTeacherCallSheetLine)) {
  1716.             $this->schoolTeacherCallSheetLines[] = $schoolTeacherCallSheetLine;
  1717.             $schoolTeacherCallSheetLine->setRegistrationStudentRegistration($this);
  1718.         }
  1720.         return $this;
  1721.     }
  1723.     public function removeSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1724.     {
  1725.         if ($this->schoolTeacherCallSheetLines->removeElement($schoolTeacherCallSheetLine)) {
  1726.             // set the owning side to null (unless already changed)
  1727.             if ($schoolTeacherCallSheetLine->getRegistrationStudentRegistration() === $this) {
  1728.                 $schoolTeacherCallSheetLine->setRegistrationStudentRegistration(null);
  1729.             }
  1730.         }
  1732.         return $this;
  1733.     }
  1735.     public function getJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1736.         $minute = 0;
  1737.         $heure = 0;
  1738.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1739.             if ($schoolAbsenceAndDelay->getIsJustify()) {
  1740.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1741.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1742.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1743.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1744.                         }
  1746.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1747.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1748.                         }
  1749.                     }
  1750.                 }
  1751.             }
  1752.         }
  1754.         $heure = ceil($heure + ($minute / 60));
  1755.         
  1756.         return $heure;
  1757.     }
  1759.     public function getNotJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1760.         $minute = 0;
  1761.         $heure = 0;
  1762.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1763.             if (!$schoolAbsenceAndDelay->getIsJustify()) {
  1764.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1765.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1766.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1767.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1768.                         }
  1770.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1771.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1772.                         }
  1773.                     }
  1774.                 }
  1775.             }
  1776.         }
  1778.         $heure = ceil($heure + ($minute / 60));
  1779.         
  1780.         return $heure;
  1781.     }
  1783.     public function isReported(){
  1784.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1785.             if ($accountingStudentRegistrationFee->getIsReported()) {
  1786.                 return true;
  1787.                 break;
  1788.             }
  1789.         }
  1791.         return false;
  1792.     }
  1794.     public function getNurseryPresence(DateTimeImmutable $startDate, DateTimeImmutable $endDate){
  1795.         
  1796.         $data = new ArrayCollection();
  1797.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1798.             if ($startDate <= $schoolTeacherCallSheetLine->getCreateDate() && $schoolTeacherCallSheetLine->getCreateDate() <= $endDate) {
  1799.                 $data->add($schoolTeacherCallSheetLine);
  1800.             }
  1801.         }
  1803.         return $data;
  1804.     }
  1806.     /**
  1807.      * @return Collection|AccountingChequeTrackingLine[]
  1808.      */
  1809.     public function getAccountingChequeTrackingLines(): Collection
  1810.     {
  1811.         return $this->accountingChequeTrackingLines;
  1812.     }
  1814.     public function addAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1815.     {
  1816.         if (!$this->accountingChequeTrackingLines->contains($accountingChequeTrackingLine)) {
  1817.             $this->accountingChequeTrackingLines[] = $accountingChequeTrackingLine;
  1818.             $accountingChequeTrackingLine->setRegistrationStudentRegistration($this);
  1819.         }
  1821.         return $this;
  1822.     }
  1824.     public function removeAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1825.     {
  1826.         if ($this->accountingChequeTrackingLines->removeElement($accountingChequeTrackingLine)) {
  1827.             // set the owning side to null (unless already changed)
  1828.             if ($accountingChequeTrackingLine->getRegistrationStudentRegistration() === $this) {
  1829.                 $accountingChequeTrackingLine->setRegistrationStudentRegistration(null);
  1830.             }
  1831.         }
  1833.         return $this;
  1834.     }
  1836.     public function getAbsenceStatus($day){
  1837.         $nb = 0;
  1838.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1839.             //if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getSchoolTeacherCallSheet()->getSettingTimeTable() == $settingTimeTable) {
  1840.             if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getIsAbsent()) {
  1841.                 $nb++;
  1842.             }
  1843.         }
  1845.         return $nb;
  1846.     }
  1848.     /**
  1849.      * @return Collection|SchoolReportCardAbsence[]
  1850.      */
  1851.     public function getSchoolReportCardAbsences(): Collection
  1852.     {
  1853.         return $this->schoolReportCardAbsences;
  1854.     }
  1856.     public function addSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1857.     {
  1858.         if (!$this->schoolReportCardAbsences->contains($schoolReportCardAbsence)) {
  1859.             $this->schoolReportCardAbsences[] = $schoolReportCardAbsence;
  1860.             $schoolReportCardAbsence->setStudentRegistration($this);
  1861.         }
  1863.         return $this;
  1864.     }
  1866.     public function removeSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1867.     {
  1868.         if ($this->schoolReportCardAbsences->removeElement($schoolReportCardAbsence)) {
  1869.             // set the owning side to null (unless already changed)
  1870.             if ($schoolReportCardAbsence->getStudentRegistration() === $this) {
  1871.                 $schoolReportCardAbsence->setStudentRegistration(null);
  1872.             }
  1873.         }
  1875.         return $this;
  1876.     }
  1878.     /**
  1879.      * @return Collection|WavePayment[]
  1880.      */
  1881.     public function getWavePayments(): Collection
  1882.     {
  1883.         return $this->wavePayments;
  1884.     }
  1886.     public function addWavePayment(WavePayment $wavePayment): self
  1887.     {
  1888.         if (!$this->wavePayments->contains($wavePayment)) {
  1889.             $this->wavePayments[] = $wavePayment;
  1890.             $wavePayment->setStudentRegistration($this);
  1891.         }
  1893.         return $this;
  1894.     }
  1896.     public function removeWavePayment(WavePayment $wavePayment): self
  1897.     {
  1898.         if ($this->wavePayments->removeElement($wavePayment)) {
  1899.             // set the owning side to null (unless already changed)
  1900.             if ($wavePayment->getStudentRegistration() === $this) {
  1901.                 $wavePayment->setStudentRegistration(null);
  1902.             }
  1903.         }
  1905.         return $this;
  1906.     }
  1907. }