src/Entity/RegistrationStudentRegistration.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\RegistrationStudentRegistrationRepository;
  6. use App\Repository\SchoolReportCardRepository;
  7. use DateTimeImmutable;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Symfony\Component\Validator\Constraints as Assert;
  17. /**
  18.  * @ORM\Entity(repositoryClass=RegistrationStudentRegistrationRepository::class)
  19.  * Inscrits
  20.  * @Vich\Uploadable
  21.  */
  22. class RegistrationStudentRegistration
  23. {
  24.     public const STATUS = ['INSCRIT' => 'INSCRIT', 'ABANDONNE' => 'ABANDONNE'];
  25.     public const STATUS_INSCRIT = 'INSCRIT';
  26.     public const STATUS_ABANDONNE = 'ABANDONNE';
  28.     /**
  29.      * @ORM\Id
  30.      * @ORM\GeneratedValue
  31.      * @ORM\Column(type="integer")
  32.      */
  33.     private $id;
  35.     /**
  36.      * @ORM\ManyToOne(targetEntity=Establishment::class, inversedBy="registrationStudentRegistrations")
  37.      * @ORM\JoinColumn(nullable=false)
  38.      */
  39.     private $establishment;
  41.     /**
  42.      * @ORM\ManyToOne(targetEntity=RegistrationStudent::class, inversedBy="registrationStudentRegistrations")
  43.      * @ORM\JoinColumn(nullable=false)
  44.      */
  45.     private $student;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=SchoolYear::class, inversedBy="registrationStudentRegistrations")
  49.      * @ORM\JoinColumn(nullable=false)
  50.      */
  51.     private $schoolYear;
  53.     /**
  54.      * @ORM\ManyToOne(targetEntity=SettingClassroom::class, inversedBy="registrationStudentRegistrations")
  55.      * @ORM\JoinColumn(nullable=false)
  56.      */
  57.     private $classroom;
  59.     /**
  60.      * @ORM\Column(type="boolean")
  61.      */
  62.     private $is_redoubling;
  64.     /**
  65.      * @ORM\Column(type="boolean")
  66.      * est boursier
  67.      */
  68.     private $is_diet;
  70.     /**
  71.      * @ORM\Column(type="boolean")
  72.      * est interne
  73.      */
  74.     private $is_internal;
  76.     /**
  77.      * @ORM\Column(type="boolean")
  78.      * est affecte(e)
  79.     */
  80.     private $is_affected;
  82.     /**
  83.      * @ORM\Column(type="date_immutable")
  84.     */
  85.     private $registered_at;
  87.     /**
  88.      * @ORM\Column(type="datetime_immutable")
  89.     */
  90.     private $created_at;
  92.     /**
  93.      * @ORM\Column(type="datetime_immutable")
  94.      */
  95.     private $updated_at;
  97.     /**
  98.      * @ORM\Column(type="integer")
  99.      */
  100.     private $created_by;
  102.     /**
  103.      * @ORM\Column(type="integer")
  104.      */
  105.     private $updated_by;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationFee::class, mappedBy="studentRegistration")
  109.      */
  110.     private $accountingStudentRegistrationFees;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=SchoolReportCard::class, mappedBy="studentRegistration")
  114.      * @ORM\OrderBy({"id" = "ASC"})
  115.      */
  116.     private $schoolReportCards;
  118.     /**
  119.      * @ORM\OneToMany(targetEntity=SchoolAverageReportCard::class, mappedBy="studentRegistration")
  120.      */
  121.     private $schoolAverageReportCards;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClass::class, mappedBy="studentRegistration")
  125.      */
  126.     private $schoolAssessmentByClasses;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevel::class, mappedBy="studentRegistration")
  130.      */
  131.     private $schoolAssessmentByLevels;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByClassByMatter::class, mappedBy="studentRegistration")
  135.      */
  136.     private $schoolAssessmentByClassByMatters;
  138.     /**
  139.      * @ORM\OneToMany(targetEntity=SchoolAssessmentByLevelByMatter::class, mappedBy="studentRegistration")
  140.      */
  141.     private $schoolAssessmentByLevelByMatters;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=AccountingStudentRegistrationPayment::class, mappedBy="studentRegistration")
  145.      */
  146.     private $accountingStudentRegistrationPayments;
  148.     /**
  149.      * @ORM\Column(type="float", nullable=true)
  150.     */
  151.     private $last_amount_paid;
  153.     /**
  154.      * @ORM\Column(type="integer", nullable=true)
  155.     */
  156.     private $last_payment_id;
  158.     /**
  159.      * @ORM\Column(type="datetime_immutable", nullable=true)
  160.     */
  161.     private $last_payment_at;
  163.     /**
  164.      * @ORM\Column(type="string", length=255, nullable=true)
  165.      */
  166.     private $image;
  168.     /**
  169.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  170.      * 
  171.      * @Vich\UploadableField(mapping="student", fileNameProperty="image")
  172.      * 
  173.      * @var File|null
  174.      * @Assert\File(
  175.      * maxSize = "25M",
  176.      * mimeTypes = {"image/png", "image/jpg", "image/jpeg"},
  177.      * mimeTypesMessage = "Veuillez télécharger une image valide (png, jpg, jpeg)",
  178.      * maxSizeMessage = "Le fichier est trop volumineux ({{size}} {{suffix}}). La taille maximale autorisée est {{limit}} {{suffix}}"
  179.      * )
  180.      */
  181.     private $imageFile;
  183.     /**
  184.      * @ORM\OneToMany(targetEntity=RegistrationClassChange::class, mappedBy="studentRegistration")
  185.      */
  186.     private $registrationClassChanges;
  188.     /**
  189.      * @ORM\OneToMany(targetEntity=RegistrationStudentDowngrade::class, mappedBy="registrationStudentRegistration")
  190.      */
  191.     private $registrationStudentDowngrades;
  193.     /**
  194.      * @ORM\OneToMany(targetEntity=RegistrationStudentAbandonment::class, mappedBy="registrationStudentRegistration")
  195.      */
  196.     private $registrationStudentAbandonments;
  198.     /**
  199.      * @ORM\Column(type="boolean")
  200.     */
  201.     private $is_abandonned;
  203.     /**
  204.      * @ORM\ManyToOne(targetEntity=RegistrationStudentPreRegistration::class, inversedBy="registrationStudentRegistrations")
  205.      */
  206.     private $registrationStudentPreRegistration;
  208.     /**
  209.      * @ORM\OneToMany(targetEntity=RegistrationTransportCheckpoint::class, mappedBy="registrationStudentRegistration")
  210.      */
  211.     private $registrationTransportCheckpoints;
  213.     /**
  214.      * @ORM\Column(type="boolean")
  215.      */
  216.     private $as_food_restrictions;
  218.     /**
  219.      * @ORM\Column(type="boolean")
  220.      */
  221.     private $is_meatless_menu;
  223.     /**
  224.      * @ORM\Column(type="boolean")
  225.      */
  226.     private $is_menu_without_pork;
  228.     /**
  229.      * @ORM\Column(type="boolean")
  230.      */
  231.     private $is_can_eat_alone;
  233.     /**
  234.      * @ORM\Column(type="boolean")
  235.      */
  236.     private $is_can_do_his_business_alone;
  238.     /**
  239.      * @ORM\Column(type="boolean")
  240.      */
  241.     private $is_falls_sleep_easily;
  243.     /**
  244.      * @ORM\OneToMany(targetEntity=SchoolAbsenceAndDelay::class, mappedBy="studentRegistration")
  245.      */
  246.     private $schoolAbsenceAndDelays;
  248.     /**
  249.      * @ORM\ManyToMany(targetEntity=SettingDocumentToProvide::class, inversedBy="registrationStudentRegistrations")
  250.      */
  251.     private $documentProvides;
  253.     /**
  254.      * @ORM\ManyToMany(targetEntity=CommunicationMessage::class, mappedBy="studentRegistrations")
  255.      */
  256.     private $communicationMessages;
  258.     /**
  259.      * @ORM\Column(type="boolean")
  260.     */
  261.     private $is_new;
  263.     /**
  264.      * @ORM\OneToMany(targetEntity=StockStudentKitEntry::class, mappedBy="registrationStudent")
  265.      */
  266.     private $stockStudentKitEntries;
  268.     /**
  269.      * @ORM\OneToMany(targetEntity=StockKitOut::class, mappedBy="registrationStudent")
  270.      */
  271.     private $stockKitOuts;
  273.     /**
  274.      * @ORM\Column(type="string", length=60, nullable=true)
  275.      */
  276.     private $portal_login;
  278.     /**
  279.      * @ORM\Column(type="string", length=60, nullable=true)
  280.      */
  281.     private $portal_password;
  283.     /**
  284.      * @ORM\OneToMany(targetEntity=AccountingCredit::class, mappedBy="studentRegistration")
  285.      */
  286.     private $accountingCredits;
  288.     /**
  289.      * @ORM\OneToMany(targetEntity=SchoolStudentAverage::class, mappedBy="registrationStudentRegistration")
  290.      */
  291.     private $schoolStudentAverages;
  293.     /**
  294.      * @ORM\OneToMany(targetEntity=NurseryTimeSheet::class, mappedBy="registrationStudentRegistration")
  295.      */
  296.     private $nurseryTimeSheets;
  298.     /**
  299.      * @ORM\OneToMany(targetEntity=SchoolTeacherCallSheetLine::class, mappedBy="registrationStudentRegistration")
  300.      */
  301.     private $schoolTeacherCallSheetLines;
  303.     /**
  304.      * @ORM\OneToMany(targetEntity=AccountingChequeTrackingLine::class, mappedBy="registrationStudentRegistration")
  305.      */
  306.     private $accountingChequeTrackingLines;
  308.     /**
  309.      * @ORM\OneToMany(targetEntity=SchoolReportCardAbsence::class, mappedBy="studentRegistration")
  310.      */
  311.     private $schoolReportCardAbsences;
  313.     /**
  314.      * @ORM\OneToMany(targetEntity=WavePayment::class, mappedBy="studentRegistration")
  315.      */
  316.     private $wavePayments;
  318.     /**
  319.      * @ORM\OneToMany(targetEntity=RegistrationStudentContact::class, mappedBy="registrationStudentRegistration")
  320.      */
  321.     private $registrationStudentContacts;
  323.     /**
  324.      * @ORM\OneToMany(targetEntity=TransportCallSheetLine::class, mappedBy="registrationStudentRegistration")
  325.      */
  326.     private $transportCallSheetLines;
  328.     /**
  329.      * @ORM\OneToMany(targetEntity=StockExitSlip::class, mappedBy="registrationStudentRegistration")
  330.      */
  331.     private $stockExitSlips;
  333.     /**
  334.      * @ORM\Column(type="boolean")
  335.      */
  336.     private $is_authorized_alone;
  338.     /**
  339.      * @ORM\Column(type="string", length=60)
  340.      */
  341.     private $status;
  343.     public function __construct()
  344.     {
  345.         $this->accountingStudentRegistrationFees = new ArrayCollection();
  346.         $this->schoolReportCards = new ArrayCollection();
  347.         $this->schoolAverageReportCards = new ArrayCollection();
  348.         $this->schoolAssessmentByClasses = new ArrayCollection();
  349.         $this->schoolAssessmentByLevels = new ArrayCollection();
  350.         $this->schoolAssessmentByClassByMatters = new ArrayCollection();
  351.         $this->schoolAssessmentByLevelByMatters = new ArrayCollection();
  352.         $this->is_affected = false;
  353.         $this->is_diet = false;
  354.         $this->is_internal = true;
  355.         $this->is_redoubling = false;
  356.         $this->is_abandonned = false;
  357.         $this->registered_at = new DateTimeImmutable();
  358.         $this->accountingStudentRegistrationPayments = new ArrayCollection();
  359.         $this->registrationClassChanges = new ArrayCollection();
  360.         $this->registrationStudentDowngrades = new ArrayCollection();
  361.         $this->registrationStudentAbandonments = new ArrayCollection();
  362.         $this->registrationTransportCheckpoints = new ArrayCollection();
  364.         $this->as_food_restrictions = false;
  365.         $this->is_meatless_menu = false;
  366.         $this->is_menu_without_pork = false;
  367.         $this->is_can_eat_alone = true;
  368.         $this->is_can_do_his_business_alone = true;
  369.         $this->is_falls_sleep_easily = false;
  370.         $this->schoolAbsenceAndDelays = new ArrayCollection();
  371.         $this->documentProvides = new ArrayCollection();
  372.         $this->communicationMessages = new ArrayCollection();
  374.         $this->is_new = false;
  375.         $this->is_authorized_alone = false;
  376.         $this->stockStudentKitEntries = new ArrayCollection();
  377.         $this->stockKitOuts = new ArrayCollection();
  378.         $this->accountingCredits = new ArrayCollection();
  379.         $this->schoolStudentAverages = new ArrayCollection();
  380.         $this->nurseryTimeSheets = new ArrayCollection();
  381.         $this->schoolTeacherCallSheetLines = new ArrayCollection();
  382.         $this->accountingChequeTrackingLines = new ArrayCollection();
  383.         $this->schoolReportCardAbsences = new ArrayCollection();
  384.         $this->wavePayments = new ArrayCollection();
  385.         $this->registrationStudentContacts = new ArrayCollection();
  386.         $this->transportCallSheetLines = new ArrayCollection();
  387.         $this->stockExitSlips = new ArrayCollection();
  388.         $this->status = self::STATUS_INSCRIT;
  389.     }
  391.     public function getName()
  392.     {
  393.         return $this->getStudent()->getName();
  394.     }
  396.     public function __toString()
  397.     {
  398.         return $this->getName().' ['.$this->getClassroom()->getLabel().']'.' ['.$this->getStudent()->getRegistrationNumber().']';
  399.     }
  401.     /**
  402.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  403.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  404.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  405.      * must be able to accept an instance of 'File' as the bundle will inject one here
  406.      * during Doctrine hydration.
  407.      *
  408.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  409.      */
  410.     public function setImageFile(?File $imageFile = null): void
  411.     {
  412.         $this->imageFile = $imageFile;
  414.         if (null !== $imageFile) {
  415.             // It is required that at least one field changes if you are using doctrine
  416.             // otherwise the event listeners won't be called and the file is lost
  417.             $this->updated_at = new \DateTimeImmutable();
  418.         }
  419.     }
  421.     public function getImageFile(): ?File
  422.     {
  423.         return $this->imageFile;
  424.     }
  426.     public function getId(): ?int
  427.     {
  428.         return $this->id;
  429.     }
  431.     public function getEstablishment(): ?Establishment
  432.     {
  433.         return $this->establishment;
  434.     }
  436.     public function setEstablishment(?Establishment $establishment): self
  437.     {
  438.         $this->establishment = $establishment;
  440.         return $this;
  441.     }
  443.     public function getStudent(): ?RegistrationStudent
  444.     {
  445.         return $this->student;
  446.     }
  448.     public function setStudent(?RegistrationStudent $student): self
  449.     {
  450.         $this->student = $student;
  452.         return $this;
  453.     }
  455.     public function getSchoolYear(): ?SchoolYear
  456.     {
  457.         return $this->schoolYear;
  458.     }
  460.     public function setSchoolYear(?SchoolYear $schoolYear): self
  461.     {
  462.         $this->schoolYear = $schoolYear;
  464.         return $this;
  465.     }
  467.     public function getClassroom(): ?SettingClassroom
  468.     {
  469.         return $this->classroom;
  470.     }
  472.     public function setClassroom(?SettingClassroom $classroom): self
  473.     {
  474.         $this->classroom = $classroom;
  476.         return $this;
  477.     }
  479.     public function getCreatedAt(): ?\DateTimeImmutable
  480.     {
  481.         return $this->created_at;
  482.     }
  484.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  485.     {
  486.         $this->created_at = $created_at;
  488.         return $this;
  489.     }
  491.     public function getUpdatedAt(): ?\DateTimeImmutable
  492.     {
  493.         return $this->updated_at;
  494.     }
  496.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  497.     {
  498.         $this->updated_at = $updated_at;
  500.         return $this;
  501.     }
  503.     public function getCreatedBy(): ?int
  504.     {
  505.         return $this->created_by;
  506.     }
  508.     public function setCreatedBy(int $created_by): self
  509.     {
  510.         $this->created_by = $created_by;
  512.         return $this;
  513.     }
  515.     public function getUpdatedBy(): ?int
  516.     {
  517.         return $this->updated_by;
  518.     }
  520.     public function setUpdatedBy(int $updated_by): self
  521.     {
  522.         $this->updated_by = $updated_by;
  524.         return $this;
  525.     }
  527.     /**
  528.      * @return Collection|AccountingStudentRegistrationFee[]
  529.      */
  530.     public function getAccountingStudentRegistrationFees(): Collection
  531.     {
  532.         return $this->accountingStudentRegistrationFees;
  533.     }
  535.     public function addAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  536.     {
  537.         if (!$this->accountingStudentRegistrationFees->contains($accountingStudentRegistrationFee)) {
  538.             $this->accountingStudentRegistrationFees[] = $accountingStudentRegistrationFee;
  539.             $accountingStudentRegistrationFee->setStudentRegistration($this);
  540.         }
  542.         return $this;
  543.     }
  545.     public function removeAccountingStudentRegistrationFee(AccountingStudentRegistrationFee $accountingStudentRegistrationFee): self
  546.     {
  547.         if ($this->accountingStudentRegistrationFees->removeElement($accountingStudentRegistrationFee)) {
  548.             // set the owning side to null (unless already changed)
  549.             if ($accountingStudentRegistrationFee->getStudentRegistration() === $this) {
  550.                 $accountingStudentRegistrationFee->setStudentRegistration(null);
  551.             }
  552.         }
  554.         return $this;
  555.     }
  557.     /**
  558.      * @return Collection|SchoolReportCard[]
  559.      */
  560.     public function getSchoolReportCards(): Collection
  561.     {
  562.         return $this->schoolReportCards;
  563.     }
  565.     public function addSchoolReportCard(SchoolReportCard $schoolReportCard): self
  566.     {
  567.         if (!$this->schoolReportCards->contains($schoolReportCard)) {
  568.             $this->schoolReportCards[] = $schoolReportCard;
  569.             $schoolReportCard->setStudentRegistration($this);
  570.         }
  572.         return $this;
  573.     }
  575.    
  576.     public function getOrderedSchoolReportCards(SchoolReportCardRepository $schoolReportCardRepository)
  577.     {
  578.         $schoolReportCards = $schoolReportCardRepository->createQueryBuilder('entity')
  579.         ->innerJoin('entity.schoolYearPeriode', 'schoolYearPeriode')
  580.         ->addSelect('schoolYearPeriode')
  582.         ->andWhere('entity.studentRegistration = :studentRegistration')
  583.         ->setParameter('studentRegistration', $this)
  585.         ->orderBy('schoolYearPeriode.code', 'ASC')
  586.         ->getQuery()
  587.         ->getResult();
  589.         return $schoolReportCards;
  590.     }
  592.     public function removeSchoolReportCard(SchoolReportCard $schoolReportCard): self
  593.     {
  594.         if ($this->schoolReportCards->removeElement($schoolReportCard)) {
  595.             // set the owning side to null (unless already changed)
  596.             if ($schoolReportCard->getStudentRegistration() === $this) {
  597.                 $schoolReportCard->setStudentRegistration(null);
  598.             }
  599.         }
  601.         return $this;
  602.     }
  604.     /**
  605.      * @return Collection|SchoolAverageReportCard[]
  606.      */
  607.     public function getSchoolAverageReportCards(): Collection
  608.     {
  609.         return $this->schoolAverageReportCards;
  610.     }
  612.     public function addSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  613.     {
  614.         if (!$this->schoolAverageReportCards->contains($schoolAverageReportCard)) {
  615.             $this->schoolAverageReportCards[] = $schoolAverageReportCard;
  616.             $schoolAverageReportCard->setStudentRegistration($this);
  617.         }
  619.         return $this;
  620.     }
  622.     public function removeSchoolAverageReportCard(SchoolAverageReportCard $schoolAverageReportCard): self
  623.     {
  624.         if ($this->schoolAverageReportCards->removeElement($schoolAverageReportCard)) {
  625.             // set the owning side to null (unless already changed)
  626.             if ($schoolAverageReportCard->getStudentRegistration() === $this) {
  627.                 $schoolAverageReportCard->setStudentRegistration(null);
  628.             }
  629.         }
  631.         return $this;
  632.     }
  634.     /**
  635.      * @return Collection|SchoolAssessmentByClass[]
  636.      */
  637.     public function getSchoolAssessmentByClasses(): Collection
  638.     {
  639.         return $this->schoolAssessmentByClasses;
  640.     }
  642.     public function addSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  643.     {
  644.         if (!$this->schoolAssessmentByClasses->contains($schoolAssessmentByClass)) {
  645.             $this->schoolAssessmentByClasses[] = $schoolAssessmentByClass;
  646.             $schoolAssessmentByClass->setStudentRegistration($this);
  647.         }
  649.         return $this;
  650.     }
  652.     public function removeSchoolAssessmentByClass(SchoolAssessmentByClass $schoolAssessmentByClass): self
  653.     {
  654.         if ($this->schoolAssessmentByClasses->removeElement($schoolAssessmentByClass)) {
  655.             // set the owning side to null (unless already changed)
  656.             if ($schoolAssessmentByClass->getStudentRegistration() === $this) {
  657.                 $schoolAssessmentByClass->setStudentRegistration(null);
  658.             }
  659.         }
  661.         return $this;
  662.     }
  664.     /**
  665.      * @return Collection|SchoolAssessmentByLevel[]
  666.      */
  667.     public function getSchoolAssessmentByLevels(): Collection
  668.     {
  669.         return $this->schoolAssessmentByLevels;
  670.     }
  672.     public function addSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  673.     {
  674.         if (!$this->schoolAssessmentByLevels->contains($schoolAssessmentByLevel)) {
  675.             $this->schoolAssessmentByLevels[] = $schoolAssessmentByLevel;
  676.             $schoolAssessmentByLevel->setStudentRegistration($this);
  677.         }
  679.         return $this;
  680.     }
  682.     public function removeSchoolAssessmentByLevel(SchoolAssessmentByLevel $schoolAssessmentByLevel): self
  683.     {
  684.         if ($this->schoolAssessmentByLevels->removeElement($schoolAssessmentByLevel)) {
  685.             // set the owning side to null (unless already changed)
  686.             if ($schoolAssessmentByLevel->getStudentRegistration() === $this) {
  687.                 $schoolAssessmentByLevel->setStudentRegistration(null);
  688.             }
  689.         }
  691.         return $this;
  692.     }
  694.     /**
  695.      * @return Collection|SchoolAssessmentByClassByMatter[]
  696.      */
  697.     public function getSchoolAssessmentByClassByMatters(): Collection
  698.     {
  699.         return $this->schoolAssessmentByClassByMatters;
  700.     }
  702.     public function addSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  703.     {
  704.         if (!$this->schoolAssessmentByClassByMatters->contains($schoolAssessmentByClassByMatter)) {
  705.             $this->schoolAssessmentByClassByMatters[] = $schoolAssessmentByClassByMatter;
  706.             $schoolAssessmentByClassByMatter->setStudentRegistration($this);
  707.         }
  709.         return $this;
  710.     }
  712.     public function removeSchoolAssessmentByClassByMatter(SchoolAssessmentByClassByMatter $schoolAssessmentByClassByMatter): self
  713.     {
  714.         if ($this->schoolAssessmentByClassByMatters->removeElement($schoolAssessmentByClassByMatter)) {
  715.             // set the owning side to null (unless already changed)
  716.             if ($schoolAssessmentByClassByMatter->getStudentRegistration() === $this) {
  717.                 $schoolAssessmentByClassByMatter->setStudentRegistration(null);
  718.             }
  719.         }
  721.         return $this;
  722.     }
  724.     /**
  725.      * @return Collection|SchoolAssessmentByLevelByMatter[]
  726.      */
  727.     public function getSchoolAssessmentByLevelByMatters(): Collection
  728.     {
  729.         return $this->schoolAssessmentByLevelByMatters;
  730.     }
  732.     public function addSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  733.     {
  734.         if (!$this->schoolAssessmentByLevelByMatters->contains($schoolAssessmentByLevelByMatter)) {
  735.             $this->schoolAssessmentByLevelByMatters[] = $schoolAssessmentByLevelByMatter;
  736.             $schoolAssessmentByLevelByMatter->setStudentRegistration($this);
  737.         }
  739.         return $this;
  740.     }
  742.     public function removeSchoolAssessmentByLevelByMatter(SchoolAssessmentByLevelByMatter $schoolAssessmentByLevelByMatter): self
  743.     {
  744.         if ($this->schoolAssessmentByLevelByMatters->removeElement($schoolAssessmentByLevelByMatter)) {
  745.             // set the owning side to null (unless already changed)
  746.             if ($schoolAssessmentByLevelByMatter->getStudentRegistration() === $this) {
  747.                 $schoolAssessmentByLevelByMatter->setStudentRegistration(null);
  748.             }
  749.         }
  751.         return $this;
  752.     }
  754.     public function getIsRedoubling(): ?bool
  755.     {
  756.         return $this->is_redoubling;
  757.     }
  759.     public function setIsRedoubling(bool $is_redoubling): self
  760.     {
  761.         $this->is_redoubling = $is_redoubling;
  763.         return $this;
  764.     }
  766.     public function getIsDiet(): ?bool
  767.     {
  768.         return $this->is_diet;
  769.     }
  771.     public function setIsDiet(bool $is_diet): self
  772.     {
  773.         $this->is_diet = $is_diet;
  775.         return $this;
  776.     }
  778.     public function getIsInternal(): ?bool
  779.     {
  780.         return $this->is_internal;
  781.     }
  783.     public function setIsInternal(bool $is_internal): self
  784.     {
  785.         $this->is_internal = $is_internal;
  787.         return $this;
  788.     }
  790.     public function getIsAffected(): ?bool
  791.     {
  792.         return $this->is_affected;
  793.     }
  795.     public function setIsAffected(bool $is_affected): self
  796.     {
  797.         $this->is_affected = $is_affected;
  799.         return $this;
  800.     }
  802.     public function getRegisteredAt(): ?\DateTimeImmutable
  803.     {
  804.         return $this->registered_at;
  805.     }
  807.     public function setRegisteredAt(\DateTimeImmutable $registered_at): self
  808.     {
  809.         $this->registered_at = $registered_at;
  811.         return $this;
  812.     }
  814.     public function getGleAmount(){
  815.         $amount = 0;
  816.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $fee) {
  817.             if (!$fee->getIsArchived()) {
  818.                 $amount = $amount + $fee->getAmount();
  819.             }
  820.         }
  822.         return $amount;
  823.     }
  825.     public function getAmountPaid(){
  826.         $amount = 0;
  827.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  828.             //if (!$accountingStudentRegistrationPayment->isCanBeShow()) {
  829.                 $amount = $amount + $accountingStudentRegistrationPayment->getAmount();
  830.             //}
  831.         }
  833.         $payArchived = 0;
  834.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  835.             if ($accountingStudentRegistrationFee->getIsArchived()) {
  836.                 $payArchived = $payArchived + $accountingStudentRegistrationFee->getAmountPaid();
  837.             }
  838.             
  839.         }
  842.         return $amount - $payArchived;
  843.     }
  845.     public function getAmountCancel(): ?float
  846.     {
  847.         $amountCancel = 0;
  848.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  849.             //if (!$accountingStudentRegistrationFee->getIsArchived()) {
  850.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountReported();
  851.             //}
  852.         }
  853.         
  854.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  855.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  856.                 $amountCancel = $amountCancel + $accountingStudentRegistrationFee->getAmountCancel();
  857.             }
  858.         }
  859.         
  860.         return $amountCancel;
  861.     }
  863.     public function getAmountRest(): ?float
  864.     {
  865.         $amount = ($this->getGleAmount() - ($this->getAmountPaid() + $this->getAmountCancel()));
  866.         return $amount > 0 ? $amount : 0;
  867.     }
  869.     /**
  870.      * @return Collection|AccountingStudentRegistrationPayment[]
  871.      */
  872.     public function getAccountingStudentRegistrationPayments(): Collection
  873.     {
  874.         return $this->accountingStudentRegistrationPayments;
  875.     }
  877.     public function addAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  878.     {
  879.         if (!$this->accountingStudentRegistrationPayments->contains($accountingStudentRegistrationPayment)) {
  880.             $this->accountingStudentRegistrationPayments[] = $accountingStudentRegistrationPayment;
  881.             $accountingStudentRegistrationPayment->setStudentRegistration($this);
  882.         }
  884.         return $this;
  885.     }
  887.     public function removeAccountingStudentRegistrationPayment(AccountingStudentRegistrationPayment $accountingStudentRegistrationPayment): self
  888.     {
  889.         if ($this->accountingStudentRegistrationPayments->removeElement($accountingStudentRegistrationPayment)) {
  890.             // set the owning side to null (unless already changed)
  891.             if ($accountingStudentRegistrationPayment->getStudentRegistration() === $this) {
  892.                 $accountingStudentRegistrationPayment->setStudentRegistration(null);
  893.             }
  894.         }
  896.         return $this;
  897.     }
  899.     public function getLastAmountPaid(): ?float
  900.     {
  901.         return $this->last_amount_paid;
  902.     }
  904.     public function setLastAmountPaid(?float $last_amount_paid): self
  905.     {
  906.         $this->last_amount_paid = $last_amount_paid;
  908.         return $this;
  909.     }
  911.     public function getLastPaymentId(): ?int
  912.     {
  913.         return $this->last_payment_id;
  914.     }
  916.     public function setLastPaymentId(?int $last_payment_id): self
  917.     {
  918.         $this->last_payment_id = $last_payment_id;
  920.         return $this;
  921.     }
  923.     public function getLastPaymentAt(): ?\DateTimeImmutable
  924.     {
  925.         return $this->last_payment_at;
  926.     }
  928.     public function setLastPaymentAt(?\DateTimeImmutable $last_payment_at): self
  929.     {
  930.         $this->last_payment_at = $last_payment_at;
  932.         return $this;
  933.     }
  935.     public function getImage(): ?string
  936.     {
  937.         return $this->image;
  938.     }
  940.     public function setImage(?string $image): self
  941.     {
  942.         $this->image = $image;
  944.         return $this;
  945.     }
  947.     /**
  948.      * @return Collection|RegistrationClassChange[]
  949.      */
  950.     public function getRegistrationClassChanges(): Collection
  951.     {
  952.         return $this->registrationClassChanges;
  953.     }
  955.     public function addRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  956.     {
  957.         if (!$this->registrationClassChanges->contains($registrationClassChange)) {
  958.             $this->registrationClassChanges[] = $registrationClassChange;
  959.             $registrationClassChange->setStudentRegistration($this);
  960.         }
  962.         return $this;
  963.     }
  965.     public function removeRegistrationClassChange(RegistrationClassChange $registrationClassChange): self
  966.     {
  967.         if ($this->registrationClassChanges->removeElement($registrationClassChange)) {
  968.             // set the owning side to null (unless already changed)
  969.             if ($registrationClassChange->getStudentRegistration() === $this) {
  970.                 $registrationClassChange->setStudentRegistration(null);
  971.             }
  972.         }
  974.         return $this;
  975.     }
  977.     /**
  978.      * @return Collection|RegistrationStudentDowngrade[]
  979.      */
  980.     public function getRegistrationStudentDowngrades(): Collection
  981.     {
  982.         return $this->registrationStudentDowngrades;
  983.     }
  985.     public function addRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  986.     {
  987.         if (!$this->registrationStudentDowngrades->contains($registrationStudentDowngrade)) {
  988.             $this->registrationStudentDowngrades[] = $registrationStudentDowngrade;
  989.             $registrationStudentDowngrade->setRegistrationStudentRegistration($this);
  990.         }
  992.         return $this;
  993.     }
  995.     public function removeRegistrationStudentDowngrade(RegistrationStudentDowngrade $registrationStudentDowngrade): self
  996.     {
  997.         if ($this->registrationStudentDowngrades->removeElement($registrationStudentDowngrade)) {
  998.             // set the owning side to null (unless already changed)
  999.             if ($registrationStudentDowngrade->getRegistrationStudentRegistration() === $this) {
  1000.                 $registrationStudentDowngrade->setRegistrationStudentRegistration(null);
  1001.             }
  1002.         }
  1004.         return $this;
  1005.     }
  1007.     /**
  1008.      * @return Collection|RegistrationStudentAbandonment[]
  1009.      */
  1010.     public function getRegistrationStudentAbandonments(): Collection
  1011.     {
  1012.         return $this->registrationStudentAbandonments;
  1013.     }
  1015.     public function addRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1016.     {
  1017.         if (!$this->registrationStudentAbandonments->contains($registrationStudentAbandonment)) {
  1018.             $this->registrationStudentAbandonments[] = $registrationStudentAbandonment;
  1019.             $registrationStudentAbandonment->setRegistrationStudentRegistration($this);
  1020.         }
  1022.         return $this;
  1023.     }
  1025.     public function removeRegistrationStudentAbandonment(RegistrationStudentAbandonment $registrationStudentAbandonment): self
  1026.     {
  1027.         if ($this->registrationStudentAbandonments->removeElement($registrationStudentAbandonment)) {
  1028.             // set the owning side to null (unless already changed)
  1029.             if ($registrationStudentAbandonment->getRegistrationStudentRegistration() === $this) {
  1030.                 $registrationStudentAbandonment->setRegistrationStudentRegistration(null);
  1031.             }
  1032.         }
  1034.         return $this;
  1035.     }
  1037.     public function getIsAbandonned(): ?bool
  1038.     {
  1039.         return $this->is_abandonned;
  1040.     }
  1042.     public function setIsAbandonned(bool $is_abandonned): self
  1043.     {
  1044.         $this->is_abandonned = $is_abandonned;
  1046.         return $this;
  1047.     }
  1049.     public function getRegistrationStudentPreRegistration(): ?RegistrationStudentPreRegistration
  1050.     {
  1051.         return $this->registrationStudentPreRegistration;
  1052.     }
  1054.     public function setRegistrationStudentPreRegistration(?RegistrationStudentPreRegistration $registrationStudentPreRegistration): self
  1055.     {
  1056.         $this->registrationStudentPreRegistration = $registrationStudentPreRegistration;
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection|RegistrationTransportCheckpoint[]
  1063.      */
  1064.     public function getRegistrationTransportCheckpoints(): Collection
  1065.     {
  1066.         return $this->registrationTransportCheckpoints;
  1067.     }
  1069.     public function addRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1070.     {
  1071.         if (!$this->registrationTransportCheckpoints->contains($registrationTransportCheckpoint)) {
  1072.             $this->registrationTransportCheckpoints[] = $registrationTransportCheckpoint;
  1073.             $registrationTransportCheckpoint->setRegistrationStudentRegistration($this);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     public function removeRegistrationTransportCheckpoint(RegistrationTransportCheckpoint $registrationTransportCheckpoint): self
  1080.     {
  1081.         if ($this->registrationTransportCheckpoints->removeElement($registrationTransportCheckpoint)) {
  1082.             // set the owning side to null (unless already changed)
  1083.             if ($registrationTransportCheckpoint->getRegistrationStudentRegistration() === $this) {
  1084.                 $registrationTransportCheckpoint->setRegistrationStudentRegistration(null);
  1085.             }
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     public function hasTransportFee(){
  1092.         $reponse = false;
  1093.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1094.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::TRANSPORT_FEE && !$accountingStudentRegistrationFee->getIsCancel() && $accountingStudentRegistrationFee->getAmountPaid() > 0 && !$accountingStudentRegistrationFee->getIsArchived()) {
  1095.                 $reponse = true;
  1096.                 break;
  1097.             }
  1098.         }
  1100.         return $reponse;
  1101.     }
  1103.     public function hasGardeMidiFee(){
  1104.         $reponse = false;
  1105.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1106.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::GARDE_MIDI_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1107.                 $reponse = true;
  1108.                 break;
  1109.             }
  1110.         }
  1112.         return $reponse;
  1113.     }
  1115.     public function hasExtraFee(){
  1116.         $reponse = false;
  1117.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1118.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::ACTIVITE_EXTAT_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1119.                 $reponse = true;
  1120.                 break;
  1121.             }
  1122.         }
  1124.         return $reponse;
  1125.     }
  1127.     public function hasCanteenFee(){
  1128.         $reponse = false;
  1129.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1130.             if($accountingStudentRegistrationFee->getFee()->getSchoolYear() == $this->getSchoolYear()) {
  1131.                 if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::CANTINE_FEE && !$accountingStudentRegistrationFee->getIsCancel()) {
  1132.                     $reponse = true;
  1133.                     break;
  1134.                 }
  1135.             }
  1136.         }
  1138.         return $reponse;
  1139.     }
  1141.     public function hasMobileApp(){
  1142.         $reponse = false;
  1143.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1144.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == SettingFee::MOBILE_APP && !$accountingStudentRegistrationFee->getIsCancel()) {
  1145.                 $reponse = true;
  1146.                 break;
  1147.             }
  1148.         }
  1150.         return $reponse;
  1151.     }
  1153.     public function getAmountDueAt(DateTimeImmutable $dueDate, $category = '0'){
  1154.         
  1155.         $amountDue = 0;
  1156.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1157.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1158.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1159.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() >= 0) {
  1160.                         if ('0' != $category) {
  1161.                             if ($accountingStudentRegistrationFee->getFee()->getCategory() == $category) {
  1162.                                 $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1163.                             }
  1164.                         }else {
  1165.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1166.                         }
  1167.                     }
  1168.                 }
  1169.             }
  1170.         }
  1172.         $amountChequeTracking = 0;
  1173.         foreach ($this->getAccountingChequeTrackingLines() as $key => $accountingChequeTrackingLine) {
  1174.             if ($accountingChequeTrackingLine->getAccountingChequeTracking()->getStatus() == AccountingChequeTracking::EN_TRAITEMENT) {
  1175.                 $amountChequeTracking += $accountingChequeTrackingLine->getAmount();
  1176.             }
  1177.         }
  1178.         
  1179.         return $amountDue - $amountChequeTracking;
  1180.     }
  1182.     public function getAmountDueAtByFee(DateTimeImmutable $dueDate, 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->getAmountRest();
  1191.                         }
  1192.                     }
  1193.                 }
  1194.             }
  1195.         }
  1196.         
  1197.         return $amountDue;
  1198.     }
  1200.     public function getAmountByFee(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->getAmount();
  1209.                         }
  1210.                     //}
  1211.                 }
  1212.             }
  1213.         }
  1214.         
  1215.         return $amountDue;
  1216.     }
  1218.     public function getAmountPaidByFee(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->getAmountPaid();
  1227.                         }
  1228.                     //}
  1229.                 }
  1230.             }
  1231.         }
  1232.         
  1233.         return $amountDue;
  1234.     }
  1236.     public function getAmountRestByFee(SettingFee $settingFee){
  1237.         
  1238.         $amountDue = 0;
  1239.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1240.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1241.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1242.                     //if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1243.                         if ($accountingStudentRegistrationFee->getFee() == $settingFee) {
  1244.                             $amountDue = $amountDue + $accountingStudentRegistrationFeeShedul->getAmountRest();
  1245.                         }
  1246.                     //}
  1247.                 }
  1248.             }
  1249.         }
  1250.         
  1251.         return $amountDue;
  1252.     }
  1254.     public function getFeeShedulDues(DateTimeImmutable $dueDate){
  1255.         $feeShedulDues = new ArrayCollection();
  1256.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1257.             if (!$accountingStudentRegistrationFee->getIsArchived()) {
  1258.                 foreach ($accountingStudentRegistrationFee->getAccountingStudentRegistrationFeeSheduls() as $key => $accountingStudentRegistrationFeeShedul) {
  1259.                     if ($accountingStudentRegistrationFeeShedul->getDateDue() <= $dueDate && $accountingStudentRegistrationFeeShedul->getAmountRest() > 0) {
  1260.                         $feeShedulDues->add($accountingStudentRegistrationFeeShedul);
  1261.                     }
  1262.                 }
  1263.             }
  1264.         }
  1265.         
  1266.         return $feeShedulDues;
  1267.     }
  1269.     public function getAsFoodRestrictions(): ?bool
  1270.     {
  1271.         return $this->as_food_restrictions;
  1272.     }
  1274.     public function setAsFoodRestrictions(bool $as_food_restrictions): self
  1275.     {
  1276.         $this->as_food_restrictions = $as_food_restrictions;
  1278.         return $this;
  1279.     }
  1281.     public function getIsMeatlessMenu(): ?bool
  1282.     {
  1283.         return $this->is_meatless_menu;
  1284.     }
  1286.     public function setIsMeatlessMenu(bool $is_meatless_menu): self
  1287.     {
  1288.         $this->is_meatless_menu = $is_meatless_menu;
  1290.         return $this;
  1291.     }
  1293.     public function getIsMenuWithoutPork(): ?bool
  1294.     {
  1295.         return $this->is_menu_without_pork;
  1296.     }
  1298.     public function setIsMenuWithoutPork(bool $is_menu_without_pork): self
  1299.     {
  1300.         $this->is_menu_without_pork = $is_menu_without_pork;
  1302.         return $this;
  1303.     }
  1305.     public function getIsCanEatAlone(): ?bool
  1306.     {
  1307.         return $this->is_can_eat_alone;
  1308.     }
  1310.     public function setIsCanEatAlone(bool $is_can_eat_alone): self
  1311.     {
  1312.         $this->is_can_eat_alone = $is_can_eat_alone;
  1314.         return $this;
  1315.     }
  1317.     public function getIsCanDoHisBusinessAlone(): ?bool
  1318.     {
  1319.         return $this->is_can_do_his_business_alone;
  1320.     }
  1322.     public function setIsCanDoHisBusinessAlone(bool $is_can_do_his_business_alone): self
  1323.     {
  1324.         $this->is_can_do_his_business_alone = $is_can_do_his_business_alone;
  1326.         return $this;
  1327.     }
  1329.     public function getIsFallsSleepEasily(): ?bool
  1330.     {
  1331.         return $this->is_falls_sleep_easily;
  1332.     }
  1334.     public function setIsFallsSleepEasily(bool $is_falls_sleep_easily): self
  1335.     {
  1336.         $this->is_falls_sleep_easily = $is_falls_sleep_easily;
  1338.         return $this;
  1339.     }
  1341.     /**
  1342.      * @return Collection|SchoolAbsenceAndDelay[]
  1343.      */
  1344.     public function getSchoolAbsenceAndDelays(): Collection
  1345.     {
  1346.         return $this->schoolAbsenceAndDelays;
  1347.     }
  1349.     public function addSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1350.     {
  1351.         if (!$this->schoolAbsenceAndDelays->contains($schoolAbsenceAndDelay)) {
  1352.             $this->schoolAbsenceAndDelays[] = $schoolAbsenceAndDelay;
  1353.             $schoolAbsenceAndDelay->setStudentRegistration($this);
  1354.         }
  1356.         return $this;
  1357.     }
  1359.     public function removeSchoolAbsenceAndDelay(SchoolAbsenceAndDelay $schoolAbsenceAndDelay): self
  1360.     {
  1361.         if ($this->schoolAbsenceAndDelays->removeElement($schoolAbsenceAndDelay)) {
  1362.             // set the owning side to null (unless already changed)
  1363.             if ($schoolAbsenceAndDelay->getStudentRegistration() === $this) {
  1364.                 $schoolAbsenceAndDelay->setStudentRegistration(null);
  1365.             }
  1366.         }
  1368.         return $this;
  1369.     }
  1371.     public function getDelayByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1372.         $minute = 0;
  1373.         $heure = 0;
  1374.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1375.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1376.                 if ($schoolAbsenceAndDelay->getSituation() == 'RETARD') {
  1377.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1378.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1379.                     }
  1381.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1382.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1383.                     }
  1384.                 }
  1385.             }
  1386.         }
  1388.         $heure = ceil($heure + ($minute / 60));
  1389.         
  1390.         return $heure;
  1391.     }
  1393.     public function getAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1394.         $minute = 0;
  1395.         $heure = 0;
  1396.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1397.             if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1398.                 if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1399.                     if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1400.                         $minute += $schoolAbsenceAndDelay->getDuration();
  1401.                     }
  1403.                     if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1404.                         $heure += $schoolAbsenceAndDelay->getDuration();
  1405.                     }
  1406.                 }
  1407.             }
  1408.         }
  1410.         $heure = ceil($heure + ($minute / 60));
  1411.         
  1412.         return $heure;
  1413.     }
  1415.     /**
  1416.      * @return Collection|SettingDocumentToProvide[]
  1417.      */
  1418.     public function getDocumentProvides(): Collection
  1419.     {
  1420.         return $this->documentProvides;
  1421.     }
  1423.     public function addDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1424.     {
  1425.         if (!$this->documentProvides->contains($documentProvide)) {
  1426.             $this->documentProvides[] = $documentProvide;
  1427.         }
  1429.         return $this;
  1430.     }
  1432.     public function removeDocumentProvide(SettingDocumentToProvide $documentProvide): self
  1433.     {
  1434.         $this->documentProvides->removeElement($documentProvide);
  1436.         return $this;
  1437.     }
  1439.     /**
  1440.      * @return Collection|CommunicationMessage[]
  1441.      */
  1442.     public function getCommunicationMessages(): Collection
  1443.     {
  1444.         return $this->communicationMessages;
  1445.     }
  1447.     public function addCommunicationMessage(CommunicationMessage $communicationMessage): self
  1448.     {
  1449.         if (!$this->communicationMessages->contains($communicationMessage)) {
  1450.             $this->communicationMessages[] = $communicationMessage;
  1451.             $communicationMessage->addStudentRegistration($this);
  1452.         }
  1454.         return $this;
  1455.     }
  1457.     public function removeCommunicationMessage(CommunicationMessage $communicationMessage): self
  1458.     {
  1459.         if ($this->communicationMessages->removeElement($communicationMessage)) {
  1460.             $communicationMessage->removeStudentRegistration($this);
  1461.         }
  1463.         return $this;
  1464.     }
  1466.     public function getIsNew(): ?bool
  1467.     {
  1468.         return $this->is_new;
  1469.     }
  1471.     public function setIsNew(bool $is_new): self
  1472.     {
  1473.         $this->is_new = $is_new;
  1475.         return $this;
  1476.     }
  1478.     /**
  1479.      * @return Collection|StockStudentKitEntry[]
  1480.      */
  1481.     public function getStockStudentKitEntries(): Collection
  1482.     {
  1483.         return $this->stockStudentKitEntries;
  1484.     }
  1486.     public function addStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1487.     {
  1488.         if (!$this->stockStudentKitEntries->contains($stockStudentKitEntry)) {
  1489.             $this->stockStudentKitEntries[] = $stockStudentKitEntry;
  1490.             $stockStudentKitEntry->setRegistrationStudent($this);
  1491.         }
  1493.         return $this;
  1494.     }
  1496.     public function removeStockStudentKitEntry(StockStudentKitEntry $stockStudentKitEntry): self
  1497.     {
  1498.         if ($this->stockStudentKitEntries->removeElement($stockStudentKitEntry)) {
  1499.             // set the owning side to null (unless already changed)
  1500.             if ($stockStudentKitEntry->getRegistrationStudent() === $this) {
  1501.                 $stockStudentKitEntry->setRegistrationStudent(null);
  1502.             }
  1503.         }
  1505.         return $this;
  1506.     }
  1508.     /**
  1509.      * @return Collection|StockKitOut[]
  1510.      */
  1511.     public function getStockKitOuts(): Collection
  1512.     {
  1513.         return $this->stockKitOuts;
  1514.     }
  1516.     public function addStockKitOut(StockKitOut $stockKitOut): self
  1517.     {
  1518.         if (!$this->stockKitOuts->contains($stockKitOut)) {
  1519.             $this->stockKitOuts[] = $stockKitOut;
  1520.             $stockKitOut->setRegistrationStudent($this);
  1521.         }
  1523.         return $this;
  1524.     }
  1526.     public function removeStockKitOut(StockKitOut $stockKitOut): self
  1527.     {
  1528.         if ($this->stockKitOuts->removeElement($stockKitOut)) {
  1529.             // set the owning side to null (unless already changed)
  1530.             if ($stockKitOut->getRegistrationStudent() === $this) {
  1531.                 $stockKitOut->setRegistrationStudent(null);
  1532.             }
  1533.         }
  1535.         return $this;
  1536.     }
  1538.     public function getPortalLogin(): ?string
  1539.     {
  1540.         return $this->portal_login;
  1541.     }
  1543.     public function setPortalLogin(?string $portal_login): self
  1544.     {
  1545.         $this->portal_login = $portal_login;
  1547.         return $this;
  1548.     }
  1550.     public function getPortalPassword(): ?string
  1551.     {
  1552.         return $this->portal_password;
  1553.     }
  1555.     public function setPortalPassword(?string $portal_password): self
  1556.     {
  1557.         $this->portal_password = $portal_password;
  1559.         return $this;
  1560.     }
  1562.     /**
  1563.      * @return Collection|AccountingCredit[]
  1564.      */
  1565.     public function getAccountingCredits(): Collection
  1566.     {
  1567.         return $this->accountingCredits;
  1568.     }
  1570.     public function addAccountingCredit(AccountingCredit $accountingCredit): self
  1571.     {
  1572.         if (!$this->accountingCredits->contains($accountingCredit)) {
  1573.             $this->accountingCredits[] = $accountingCredit;
  1574.             $accountingCredit->setStudentRegistration($this);
  1575.         }
  1577.         return $this;
  1578.     }
  1580.     public function removeAccountingCredit(AccountingCredit $accountingCredit): self
  1581.     {
  1582.         if ($this->accountingCredits->removeElement($accountingCredit)) {
  1583.             // set the owning side to null (unless already changed)
  1584.             if ($accountingCredit->getStudentRegistration() === $this) {
  1585.                 $accountingCredit->setStudentRegistration(null);
  1586.             }
  1587.         }
  1589.         return $this;
  1590.     }
  1592.     /**
  1593.      * @return Collection|SchoolStudentAverage[]
  1594.      */
  1595.     public function getSchoolStudentAverages(): Collection
  1596.     {
  1597.         return $this->schoolStudentAverages;
  1598.     }
  1600.     public function addSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1601.     {
  1602.         if (!$this->schoolStudentAverages->contains($schoolStudentAverage)) {
  1603.             $this->schoolStudentAverages[] = $schoolStudentAverage;
  1604.             $schoolStudentAverage->setRegistrationStudentRegistration($this);
  1605.         }
  1607.         return $this;
  1608.     }
  1610.     public function removeSchoolStudentAverage(SchoolStudentAverage $schoolStudentAverage): self
  1611.     {
  1612.         if ($this->schoolStudentAverages->removeElement($schoolStudentAverage)) {
  1613.             // set the owning side to null (unless already changed)
  1614.             if ($schoolStudentAverage->getRegistrationStudentRegistration() === $this) {
  1615.                 $schoolStudentAverage->setRegistrationStudentRegistration(null);
  1616.             }
  1617.         }
  1619.         return $this;
  1620.     }
  1622.     public function computePeriodeAverage(SchoolMatter $schoolMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1623.         if (count($schoolMatter->getSchoolSubMatters()) > 0) {
  1624.             $averages = 0;
  1625.             $periodeAverage = 0;
  1626.             $count = 0;
  1627.             $coeffecient = 0;
  1628.             foreach ($schoolMatter->getSchoolSubMatters() as $key => $schoolSubMatter) {
  1629.                 $_averages = 0;
  1630.                 $_periodeAverage = 0;
  1631.                 $_count = 0;
  1632.                 $_coeffecient = 0;
  1633.                 foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1634.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  1635.                         if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1636.                             $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1637.                             if (!$schoolStudentAverage->getIsUnclassified()) {
  1638.                                 if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1639.                                     if ($schoolStudentAverage->getSubMatter() != null) {
  1640.                                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1641.                                             $_count ++;
  1642.                                             if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1643.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1644.                                                     $averages += $schoolStudentAverage->getNote();
  1645.                                                     //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1646.                                                     $_coeffecient += 1;
  1647.                                                 }
  1648.                                             }else {
  1649.                                                 if($schoolStudentAverage->getNote() < 999.0){
  1650.                                                     //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getSubMatter()->getCoefficient();
  1651.                                                     //$coeffecient += $schoolStudentAverage->getSubMatter()->getCoefficient();
  1652.                                                     $_averages += $schoolStudentAverage->getNote();
  1653.                                                     $_coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1654.                                                 }
  1655.                                             }
  1656.                                         }
  1657.                                     }
  1658.                                 }
  1659.                             }
  1660.                         }
  1661.                     }
  1662.                 }
  1663.                 
  1664.                 if ($_coeffecient > 0) {
  1665.                     $_periodeAverage = $_averages / $_coeffecient;
  1666.                     $averages += ($_periodeAverage * $schoolSubMatter->getCoefficient()); 
  1667.                     $coeffecient += $schoolSubMatter->getCoefficient(); 
  1668.                 }else {
  1669.                     $_periodeAverage = 999;
  1670.                 }
  1671.             }
  1673.             if ($coeffecient > 0) {
  1674.                 $periodeAverage = $averages / $coeffecient;
  1675.             }else {
  1676.                 $periodeAverage = 999;
  1677.             }
  1679.             return $periodeAverage;
  1680.         }else {
  1681.             $averages = 0;
  1682.             $periodeAverage = 0;
  1683.             $count = 0;
  1684.             $coeffecient = 0;
  1685.             foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1686.                 if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1687.                     $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1688.                     if (!$schoolStudentAverage->getIsUnclassified()) {
  1689.                         if ($schoolStudentAverage->getMatter() == $schoolMatter) {
  1690.                             if ($schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1691.                                 $count++;
  1692.                                 if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1693.                                     if($schoolStudentAverage->getNote() < 999.0){
  1694.                                         $averages += $schoolStudentAverage->getNote();
  1695.                                         //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1696.                                         $coeffecient += 1;
  1697.                                     }
  1698.                                 }else {
  1699.                                     if($schoolStudentAverage->getNote() < 999.0){
  1700.                                         //$averages += $schoolStudentAverage->getNote() * $schoolStudentAverage->getMatter()->getCoefficient();
  1701.                                         //$coeffecient += $schoolStudentAverage->getMatter()->getCoefficient();
  1702.                                         
  1703.                                         $averages += $schoolStudentAverage->getNote();
  1704.                                         $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1705.                                     }
  1706.                                 }
  1707.                             }
  1708.                         }
  1709.                     }
  1710.                 }
  1711.             }
  1712.             
  1713.             if ($coeffecient > 0) {
  1714.                 $periodeAverage = $averages / $coeffecient;
  1715.             }else {
  1716.                 $periodeAverage = 999;
  1717.             }
  1719.             return $periodeAverage;
  1720.         }
  1721.     }
  1723.     public function computeSubPeriodeAverage(SchoolSubMatter $schoolSubMatter, ReportCard $reportCard, SchoolAverageReportCard $schoolAverageReportCard){
  1724.         $averages = 0;
  1725.         $periodeAverage = 0;
  1726.         $count = 0;
  1727.         $coeffecient = 0;
  1728.         
  1729.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1730.             if ($schoolStudentAverage->getSchoolAverage()->getIsValidated()) {
  1731.                 $schoolAverageReportCard->setSchoolTeacher($schoolStudentAverage->getSchoolAverage()->getSchoolTeacher());
  1732.                 if (!$schoolStudentAverage->getIsUnclassified()) {
  1733.                     if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1734.                         $count++;
  1735.                         if ($this->getEstablishment()->getType() == Establishment::ESTABLISHMENT_PRESCOLAIRE_PRIMAIRE_TYPES) {
  1736.                             if($schoolStudentAverage->getNote() < 999){
  1737.                                 $averages += $schoolStudentAverage->getNote();
  1738.                                 //$coeffecient += ($schoolStudentAverage->getNoteOn() / $reportCard->getNoteOn());
  1739.                                 $coeffecient += 1;
  1740.                             }
  1741.                         }else {
  1742.                             if($schoolStudentAverage->getNote() < 999){
  1743.                                 //$averages += $schoolStudentAverage->getNote() * $schoolSubMatter->getCoefficient();
  1744.                                 //$coeffecient += $schoolSubMatter->getCoefficient();
  1746.                                 $averages += $schoolStudentAverage->getNote();
  1747.                                 $coeffecient += ($schoolStudentAverage->getSchoolAverage()->getNoteOn() / 20);
  1748.                             }
  1749.                         }
  1750.                         
  1751.                     }
  1752.                 }
  1753.             }
  1754.         }
  1755.         
  1756.         if ($coeffecient > 0) {
  1757.             $periodeAverage = $averages / $coeffecient;
  1758.         }else {
  1759.             $periodeAverage = 999;
  1760.         }
  1762.         return $periodeAverage;
  1763.     }
  1765.     public function asMatterDone(SchoolMatter $schoolMatter, ReportCard $reportCard){
  1766.         
  1767.         $count = 0;
  1768.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  1769.             if ($schoolStudentAverage->getMatter() == $schoolMatter && $schoolStudentAverage->getSchoolYearPeriode() == $reportCard->getSchoolYearPeriode()) {
  1770.                 
  1771.                 $count++;
  1772.             }
  1773.         }
  1775.         return $count > 0;
  1776.     }
  1778.     public function getAnnualAverage(): ?float
  1779.     {
  1780.         $annual_average = 0;
  1781.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1782.             $annual_average = $schoolReportCard->getAnnualAverage();
  1783.         }
  1784.         return $annual_average;
  1785.     }
  1787.     public function getAnnualRank(): ?string
  1788.     {
  1789.         $annual_rank = 0;
  1790.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  1791.             $annual_rank = $schoolReportCard->getAnnualRank();
  1792.         }
  1793.         return $annual_rank;
  1794.     }
  1796.     /**
  1797.      * @return Collection|NurseryTimeSheet[]
  1798.      */
  1799.     public function getNurseryTimeSheets(): Collection
  1800.     {
  1801.         return $this->nurseryTimeSheets;
  1802.     }
  1804.     public function addNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1805.     {
  1806.         if (!$this->nurseryTimeSheets->contains($nurseryTimeSheet)) {
  1807.             $this->nurseryTimeSheets[] = $nurseryTimeSheet;
  1808.             $nurseryTimeSheet->setRegistrationStudentRegistration($this);
  1809.         }
  1811.         return $this;
  1812.     }
  1814.     public function removeNurseryTimeSheet(NurseryTimeSheet $nurseryTimeSheet): self
  1815.     {
  1816.         if ($this->nurseryTimeSheets->removeElement($nurseryTimeSheet)) {
  1817.             // set the owning side to null (unless already changed)
  1818.             if ($nurseryTimeSheet->getRegistrationStudentRegistration() === $this) {
  1819.                 $nurseryTimeSheet->setRegistrationStudentRegistration(null);
  1820.             }
  1821.         }
  1823.         return $this;
  1824.     }
  1826.     /**
  1827.      * @return Collection|SchoolTeacherCallSheetLine[]
  1828.      */
  1829.     public function getSchoolTeacherCallSheetLines(): Collection
  1830.     {
  1831.         return $this->schoolTeacherCallSheetLines;
  1832.     }
  1834.     public function addSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1835.     {
  1836.         if (!$this->schoolTeacherCallSheetLines->contains($schoolTeacherCallSheetLine)) {
  1837.             $this->schoolTeacherCallSheetLines[] = $schoolTeacherCallSheetLine;
  1838.             $schoolTeacherCallSheetLine->setRegistrationStudentRegistration($this);
  1839.         }
  1841.         return $this;
  1842.     }
  1844.     public function removeSchoolTeacherCallSheetLine(SchoolTeacherCallSheetLine $schoolTeacherCallSheetLine): self
  1845.     {
  1846.         if ($this->schoolTeacherCallSheetLines->removeElement($schoolTeacherCallSheetLine)) {
  1847.             // set the owning side to null (unless already changed)
  1848.             if ($schoolTeacherCallSheetLine->getRegistrationStudentRegistration() === $this) {
  1849.                 $schoolTeacherCallSheetLine->setRegistrationStudentRegistration(null);
  1850.             }
  1851.         }
  1853.         return $this;
  1854.     }
  1856.     public function getJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1857.         $minute = 0;
  1858.         $heure = 0;
  1859.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1860.             if ($schoolAbsenceAndDelay->getIsJustify()) {
  1861.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1862.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1863.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1864.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1865.                         }
  1867.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1868.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1869.                         }
  1870.                     }
  1871.                 }
  1872.             }
  1873.         }
  1875.         $heure = ceil($heure + ($minute / 60));
  1876.         
  1877.         return $heure;
  1878.     }
  1880.     public function getNotJustifydAbsenceByPeriode(SchoolYearPeriode $schoolYearPeriode){
  1881.         $minute = 0;
  1882.         $heure = 0;
  1883.         foreach ($this->getSchoolAbsenceAndDelays() as $key => $schoolAbsenceAndDelay) {
  1884.             if (!$schoolAbsenceAndDelay->getIsJustify()) {
  1885.                 if ($schoolAbsenceAndDelay->getSchoolYearPeriode() == $schoolYearPeriode) {
  1886.                     if ($schoolAbsenceAndDelay->getSituation() == 'ABSENCE') {
  1887.                         if ($schoolAbsenceAndDelay->getDurationType() == 'MINUTE') {
  1888.                             $minute += $schoolAbsenceAndDelay->getDuration();
  1889.                         }
  1891.                         if ($schoolAbsenceAndDelay->getDurationType() == 'HEURE') {
  1892.                             $heure += $schoolAbsenceAndDelay->getDuration();
  1893.                         }
  1894.                     }
  1895.                 }
  1896.             }
  1897.         }
  1899.         $heure = ceil($heure + ($minute / 60));
  1900.         
  1901.         return $heure;
  1902.     }
  1904.     public function isReported(){
  1905.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  1906.             if ($accountingStudentRegistrationFee->getIsReported()) {
  1907.                 return true;
  1908.                 break;
  1909.             }
  1910.         }
  1912.         return false;
  1913.     }
  1915.     public function getNurseryPresence(DateTimeImmutable $startDate, DateTimeImmutable $endDate){
  1916.         
  1917.         $data = new ArrayCollection();
  1918.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1919.             if ($startDate <= $schoolTeacherCallSheetLine->getCreateDate() && $schoolTeacherCallSheetLine->getCreateDate() <= $endDate) {
  1920.                 $data->add($schoolTeacherCallSheetLine);
  1921.             }
  1922.         }
  1924.         return $data;
  1925.     }
  1927.     /**
  1928.      * @return Collection|AccountingChequeTrackingLine[]
  1929.      */
  1930.     public function getAccountingChequeTrackingLines(): Collection
  1931.     {
  1932.         return $this->accountingChequeTrackingLines;
  1933.     }
  1935.     public function addAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1936.     {
  1937.         if (!$this->accountingChequeTrackingLines->contains($accountingChequeTrackingLine)) {
  1938.             $this->accountingChequeTrackingLines[] = $accountingChequeTrackingLine;
  1939.             $accountingChequeTrackingLine->setRegistrationStudentRegistration($this);
  1940.         }
  1942.         return $this;
  1943.     }
  1945.     public function removeAccountingChequeTrackingLine(AccountingChequeTrackingLine $accountingChequeTrackingLine): self
  1946.     {
  1947.         if ($this->accountingChequeTrackingLines->removeElement($accountingChequeTrackingLine)) {
  1948.             // set the owning side to null (unless already changed)
  1949.             if ($accountingChequeTrackingLine->getRegistrationStudentRegistration() === $this) {
  1950.                 $accountingChequeTrackingLine->setRegistrationStudentRegistration(null);
  1951.             }
  1952.         }
  1954.         return $this;
  1955.     }
  1957.     public function getAbsenceStatus($day){
  1958.         $nb = 0;
  1959.         foreach ($this->getSchoolTeacherCallSheetLines() as $key => $schoolTeacherCallSheetLine) {
  1960.             //if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getSchoolTeacherCallSheet()->getSettingTimeTable() == $settingTimeTable) {
  1961.             if ($day == $schoolTeacherCallSheetLine->getCreateDate()->format('Y-m-d') && $schoolTeacherCallSheetLine->getIsAbsent()) {
  1962.                 $nb++;
  1963.             }
  1964.         }
  1966.         return $nb;
  1967.     }
  1969.     /**
  1970.      * @return Collection|SchoolReportCardAbsence[]
  1971.      */
  1972.     public function getSchoolReportCardAbsences(): Collection
  1973.     {
  1974.         return $this->schoolReportCardAbsences;
  1975.     }
  1977.     public function addSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1978.     {
  1979.         if (!$this->schoolReportCardAbsences->contains($schoolReportCardAbsence)) {
  1980.             $this->schoolReportCardAbsences[] = $schoolReportCardAbsence;
  1981.             $schoolReportCardAbsence->setStudentRegistration($this);
  1982.         }
  1984.         return $this;
  1985.     }
  1987.     public function removeSchoolReportCardAbsence(SchoolReportCardAbsence $schoolReportCardAbsence): self
  1988.     {
  1989.         if ($this->schoolReportCardAbsences->removeElement($schoolReportCardAbsence)) {
  1990.             // set the owning side to null (unless already changed)
  1991.             if ($schoolReportCardAbsence->getStudentRegistration() === $this) {
  1992.                 $schoolReportCardAbsence->setStudentRegistration(null);
  1993.             }
  1994.         }
  1996.         return $this;
  1997.     }
  1999.     /**
  2000.      * @return Collection|WavePayment[]
  2001.      */
  2002.     public function getWavePayments(): Collection
  2003.     {
  2004.         return $this->wavePayments;
  2005.     }
  2007.     public function addWavePayment(WavePayment $wavePayment): self
  2008.     {
  2009.         if (!$this->wavePayments->contains($wavePayment)) {
  2010.             $this->wavePayments[] = $wavePayment;
  2011.             $wavePayment->setStudentRegistration($this);
  2012.         }
  2014.         return $this;
  2015.     }
  2017.     public function removeWavePayment(WavePayment $wavePayment): self
  2018.     {
  2019.         if ($this->wavePayments->removeElement($wavePayment)) {
  2020.             // set the owning side to null (unless already changed)
  2021.             if ($wavePayment->getStudentRegistration() === $this) {
  2022.                 $wavePayment->setStudentRegistration(null);
  2023.             }
  2024.         }
  2026.         return $this;
  2027.     }
  2029.     public function getSchoolAverage(SchoolAverage $schoolAverage){
  2030.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2031.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2032.                 if ($schoolStudentAverage->getNote() == 999 || $schoolStudentAverage->getIsUnclassified()) {
  2033.                     return false;
  2034.                 }
  2036.                 return $schoolStudentAverage->getNote();
  2037.             }
  2038.         }
  2040.         return false;
  2041.     }
  2043.    
  2045.     public function getSchoolAverageSub(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2046.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2047.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2048.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2049.                     if ($schoolStudentAverage->getNote() == 999 || $schoolStudentAverage->getIsUnclassified()) {
  2050.                         return false;
  2051.                     }
  2052.                     return $schoolStudentAverage->getNote();
  2053.                 }
  2054.             }
  2055.         }
  2057.         return false;
  2058.     }
  2060.     public function getSchoolAverageMaterLabel(SchoolAverage $schoolAverage){
  2061.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2062.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2063.                 if ($schoolStudentAverage->getSubMatter()) {
  2064.                     return $schoolStudentAverage->getSubMatter()->getCode();
  2065.                 }
  2066.                 
  2067.             }
  2068.         }
  2070.         return false;
  2071.     }
  2073.     public function getSchoolAverageCoeff(SchoolAverage $schoolAverage){
  2074.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2075.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2076.                 return $schoolStudentAverage->getCoefficient();
  2077.             }
  2078.         }
  2080.         return false;
  2081.     }
  2083.     public function getSchoolSubAverageCoeff(SchoolAverage $schoolAverage, SchoolSubMatter $schoolSubMatter){
  2084.         foreach ($this->getSchoolStudentAverages() as $key => $schoolStudentAverage) {
  2085.             if ($schoolStudentAverage->getSchoolAverage() == $schoolAverage) {
  2086.                 if ($schoolStudentAverage->getSubMatter() == $schoolSubMatter) {
  2087.                     return $schoolStudentAverage->getCoefficient();
  2088.                 }
  2089.             }
  2090.         }
  2092.         return false;
  2093.     }
  2095.     public function average_report_card(SchoolYearPeriode $schoolYearPeriode, SchoolMatter $schoolMatter){
  2096.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2097.             if ($schoolAverageReportCard->getMatter() == $schoolMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2098.                 return $schoolAverageReportCard;
  2099.             }
  2100.         }
  2102.         return new SchoolAverageReportCard();
  2103.     }
  2105.     public function average_report_card_sub(SchoolYearPeriode $schoolYearPeriode, SchoolSubMatter $schoolSubMatter){
  2106.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2107.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2108.                 return $schoolAverageReportCard;
  2109.             }
  2110.         }
  2112.         return new SchoolAverageReportCard();
  2113.     }
  2115.     public function annual_average_report_card(SchoolMatter $schoolMatter){
  2116.         $averageReportCard = new SchoolAverageReportCard();
  2117.         
  2118.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2119.             if ($schoolAverageReportCard->getMatter() == $schoolMatter) {
  2120.                 $averageReportCard = $schoolAverageReportCard;
  2121.             }
  2122.         }
  2124.         return $averageReportCard;
  2125.     }
  2127.     public function annual_average_report_card_sub(SchoolSubMatter $schoolSubMatter){
  2128.         $averageReportCard = new SchoolAverageReportCard();
  2130.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2131.             if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2132.                 $averageReportCard = $schoolAverageReportCard;
  2133.             }
  2134.         }
  2136.         return $averageReportCard;
  2137.     }
  2139.     public function last_report_card(){
  2140.         $reportCard = new SchoolReportCard();
  2142.         foreach ($this->getSchoolReportCards() as $key => $schoolReportCard) {
  2143.             //if ($schoolAverageReportCard->getSubMatter() == $schoolSubMatter) {
  2144.                 $reportCard = $schoolReportCard;
  2145.             //}
  2146.         }
  2148.         return $reportCard;
  2149.     }
  2151.     public function average_report_card_type(SchoolYearPeriode $schoolYearPeriode, SchoolMatterType $schoolMatterType){
  2152.         $sCoeff = 0;
  2153.         $sXCoeff = 0;
  2154.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2155.             if ($schoolAverageReportCard->getMatter()->getMatterType() == $schoolMatterType && $schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2156.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2157.                 $sCoeff += $schoolAverageReportCard->getCoefficient();
  2158.             }
  2159.         }
  2161.         if ($sCoeff > 0) {
  2162.             return ($sXCoeff / $sCoeff);
  2163.         }
  2165.         return 0;
  2166.     }
  2168.     public function total_xaverage_report_card(SchoolYearPeriode $schoolYearPeriode){
  2169.         $sXCoeff = 0;
  2170.         foreach ($this->getSchoolAverageReportCards() as $key => $schoolAverageReportCard) {
  2171.             if ($schoolAverageReportCard->getSchoolYearPeriode() == $schoolYearPeriode) {
  2172.                 $sXCoeff += $schoolAverageReportCard->getCoefficientXAverage();
  2173.             }
  2174.         }
  2176.         return $sXCoeff;
  2177.     }
  2179.     /**
  2180.      * @return Collection|RegistrationStudentContact[]
  2181.      */
  2182.     public function getRegistrationStudentContacts(): Collection
  2183.     {
  2184.         return $this->registrationStudentContacts;
  2185.     }
  2187.     public function addRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2188.     {
  2189.         if (!$this->registrationStudentContacts->contains($registrationStudentContact)) {
  2190.             $this->registrationStudentContacts[] = $registrationStudentContact;
  2191.             $registrationStudentContact->setRegistrationStudentRegistration($this);
  2192.         }
  2194.         return $this;
  2195.     }
  2197.     public function removeRegistrationStudentContact(RegistrationStudentContact $registrationStudentContact): self
  2198.     {
  2199.         if ($this->registrationStudentContacts->removeElement($registrationStudentContact)) {
  2200.             // set the owning side to null (unless already changed)
  2201.             if ($registrationStudentContact->getRegistrationStudentRegistration() === $this) {
  2202.                 $registrationStudentContact->setRegistrationStudentRegistration(null);
  2203.             }
  2204.         }
  2206.         return $this;
  2207.     }
  2209.     /**
  2210.      * @return Collection|TransportCallSheetLine[]
  2211.      */
  2212.     public function getTransportCallSheetLines(): Collection
  2213.     {
  2214.         return $this->transportCallSheetLines;
  2215.     }
  2217.     public function addTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2218.     {
  2219.         if (!$this->transportCallSheetLines->contains($transportCallSheetLine)) {
  2220.             $this->transportCallSheetLines[] = $transportCallSheetLine;
  2221.             $transportCallSheetLine->setRegistrationStudentRegistration($this);
  2222.         }
  2224.         return $this;
  2225.     }
  2227.     public function removeTransportCallSheetLine(TransportCallSheetLine $transportCallSheetLine): self
  2228.     {
  2229.         if ($this->transportCallSheetLines->removeElement($transportCallSheetLine)) {
  2230.             // set the owning side to null (unless already changed)
  2231.             if ($transportCallSheetLine->getRegistrationStudentRegistration() === $this) {
  2232.                 $transportCallSheetLine->setRegistrationStudentRegistration(null);
  2233.             }
  2234.         }
  2236.         return $this;
  2237.     }
  2239.     /**
  2240.      * @return Collection|StockExitSlip[]
  2241.      */
  2242.     public function getStockExitSlips(): Collection
  2243.     {
  2244.         return $this->stockExitSlips;
  2245.     }
  2247.     public function addStockExitSlip(StockExitSlip $stockExitSlip): self
  2248.     {
  2249.         if (!$this->stockExitSlips->contains($stockExitSlip)) {
  2250.             $this->stockExitSlips[] = $stockExitSlip;
  2251.             $stockExitSlip->setRegistrationStudentRegistration($this);
  2252.         }
  2254.         return $this;
  2255.     }
  2257.     public function removeStockExitSlip(StockExitSlip $stockExitSlip): self
  2258.     {
  2259.         if ($this->stockExitSlips->removeElement($stockExitSlip)) {
  2260.             // set the owning side to null (unless already changed)
  2261.             if ($stockExitSlip->getRegistrationStudentRegistration() === $this) {
  2262.                 $stockExitSlip->setRegistrationStudentRegistration(null);
  2263.             }
  2264.         }
  2266.         return $this;
  2267.     }
  2269.     public function getTotalSchooling(){
  2270.         $total = 0;
  2272.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2273.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2274.                 $total += $accountingStudentRegistrationFee->getAmount();
  2275.             }
  2276.         }
  2278.         return $total;
  2279.     }
  2281.     public function getSchooling(){
  2282.         $data = new ArrayCollection();
  2284.         foreach ($this->getAccountingStudentRegistrationFees() as $key => $accountingStudentRegistrationFee) {
  2285.             if ($accountingStudentRegistrationFee->getFee()->getCategory() == 'SCOLARITE') {
  2286.                 $data->add($accountingStudentRegistrationFee);
  2287.             }
  2288.         }
  2290.         return $data;
  2291.     }
  2293.     public function getFirstPayment(){
  2294.         foreach ($this->getAccountingStudentRegistrationPayments() as $key => $accountingStudentRegistrationPayment) {
  2295.             return $accountingStudentRegistrationPayment->getAmount();
  2296.         }
  2298.         return 0;
  2299.     }
  2301.     public function getIsAuthorizedAlone(): ?bool
  2302.     {
  2303.         return $this->is_authorized_alone;
  2304.     }
  2306.     public function setIsAuthorizedAlone(bool $is_authorized_alone): self
  2307.     {
  2308.         $this->is_authorized_alone = $is_authorized_alone;
  2310.         return $this;
  2311.     }
  2313.     public function getStatus(): ?string
  2314.     {
  2315.         return $this->status;
  2316.     }
  2318.     public function setStatus(string $status): self
  2319.     {
  2320.         $this->status = $status;
  2322.         return $this;
  2323.     }
  2325.     public function isInscrit(): bool
  2326.     {
  2327.         return $this->status === self::STATUS_INSCRIT || $this->status === '';
  2328.     }
  2330.     public function isAbandonne(): bool
  2331.     {
  2332.         return $this->status === self::STATUS_ABANDONNE;
  2333.     }
  2334. }