src/Entity/Quarter.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\Timestampable;
  6. use App\Repository\QuarterRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use JMS\Serializer\Annotation\Groups;
  12. #[ORM\HasLifecycleCallbacks]
  13. #[ORM\Entity(repositoryClass: QuarterRepository::class)]
  14. class Quarter
  15. {
  16.     use Timestampable;
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex'])]
  26.     private ?string $name = null;
  28.     #[ORM\Column(nullable: true)]
  29.     private ?float $coef = null;
  31.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: Exams::class, orphanRemoval: true)]
  32.     private Collection $exams;
  34.     #[ORM\ManyToOne(inversedBy: 'quarters', cascade: ["persist"])]
  35.     #[ORM\JoinColumn(nullable: false)]
  36.     private ?SchoolYear $year = null;
  38.     #[ORM\ManyToOne(inversedBy: 'quarters', cascade: ["persist"])]
  39.     #[ORM\JoinColumn(nullable: false)]
  40.     private ?User $author = null;
  42.     #[ORM\ManyToOne(inversedBy: 'quarter')]
  43.     #[ORM\JoinColumn(nullable: true)]
  44.     private ?GlobalQuarter $globalQuarter = null;
  46.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineBlame::class)]
  47.     private Collection $disciplineBlames;
  49.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineWarning::class)]
  50.     private Collection $disciplineWarnings;
  52.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineRetained::class)]
  53.     private Collection $disciplineRetaineds;
  55.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplinePunish::class)]
  56.     private Collection $disciplinePunishes;
  58.     #[ORM\Column(length: 255)]
  59.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex'])]
  60.     private ?string $nameEn = null;
  62.     #[ORM\Column(length: 255, nullable: true)]
  63.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex'])]
  64.     private ?string $slug = null;
  66.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineConcile::class)]
  67.     private Collection $disciplineConciles;
  69.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineExclusion::class)]
  70.     private Collection $disciplineExclusions;
  72.     #[ORM\ManyToOne(inversedBy: 'quarter')]
  73.     private ?Agenda $agenda = null;
  75.     public function __construct()
  76.     {
  77.         $this->exams = new ArrayCollection();
  78.         $this->disciplineBlames = new ArrayCollection();
  79.         $this->disciplineWarnings = new ArrayCollection();
  80.         $this->disciplineRetaineds = new ArrayCollection();
  81.         $this->disciplinePunishes = new ArrayCollection();
  82.         $this->disciplineConciles = new ArrayCollection();
  83.         $this->disciplineExclusions = new ArrayCollection();
  84.     }
  86.     public function getId(): ?int
  87.     {
  88.         return $this->id;
  89.     }
  91.     public function getName(): ?string
  92.     {
  93.         return $this->name;
  94.     }
  96.     public function setName(string $name): static
  97.     {
  98.         $this->name = $name;
  100.         return $this;
  101.     }
  103.     public function getCoef(): ?float
  104.     {
  105.         return $this->coef;
  106.     }
  108.     public function setCoef(?float $coef): static
  109.     {
  110.         $this->coef = $coef;
  112.         return $this;
  113.     }
  115.     /**
  116.      * @return Collection<int, Exams>
  117.      */
  118.     public function getExams(): Collection
  119.     {
  120.         return $this->exams;
  121.     }
  123.     public function addExam(Exams $exam): static
  124.     {
  125.         if (!$this->exams->contains($exam)) {
  126.             $this->exams->add($exam);
  127.             $exam->setQuarter($this);
  128.         }
  130.         return $this;
  131.     }
  133.     public function removeExam(Exams $exam): static
  134.     {
  135.         if ($this->exams->removeElement($exam)) {
  136.             // set the owning side to null (unless already changed)
  137.             if ($exam->getQuarter() === $this) {
  138.                 $exam->setQuarter(null);
  139.             }
  140.         }
  142.         return $this;
  143.     }
  145.     public function getYear(): ?SchoolYear
  146.     {
  147.         return $this->year;
  148.     }
  150.     public function setYear(?SchoolYear $year): static
  151.     {
  152.         $this->year = $year;
  154.         return $this;
  155.     }
  157.     public function getAuthor(): ?User
  158.     {
  159.         return $this->author;
  160.     }
  162.     public function setAuthor(?User $author): static
  163.     {
  164.         $this->author = $author;
  166.         return $this;
  167.     }
  169.     public function getGlobalQuarter(): ?GlobalQuarter
  170.     {
  171.         return $this->globalQuarter;
  172.     }
  174.     public function setGlobalQuarter(?GlobalQuarter $globalQuarter): static
  175.     {
  176.         $this->globalQuarter = $globalQuarter;
  178.         return $this;
  179.     }
  181.     /**
  182.      * @return Collection<int, DisciplineBlame>
  183.      */
  184.     public function getDisciplineBlames(): Collection
  185.     {
  186.         return $this->disciplineBlames;
  187.     }
  189.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  190.     {
  191.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  192.             $this->disciplineBlames->add($disciplineBlame);
  193.             $disciplineBlame->setQuarter($this);
  194.         }
  196.         return $this;
  197.     }
  199.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  200.     {
  201.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  202.             // set the owning side to null (unless already changed)
  203.             if ($disciplineBlame->getQuarter() === $this) {
  204.                 $disciplineBlame->setQuarter(null);
  205.             }
  206.         }
  208.         return $this;
  209.     }
  211.     /**
  212.      * @return Collection<int, DisciplineWarning>
  213.      */
  214.     public function getDisciplineWarnings(): Collection
  215.     {
  216.         return $this->disciplineWarnings;
  217.     }
  219.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  220.     {
  221.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  222.             $this->disciplineWarnings->add($disciplineWarning);
  223.             $disciplineWarning->setQuarter($this);
  224.         }
  226.         return $this;
  227.     }
  229.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  230.     {
  231.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  232.             // set the owning side to null (unless already changed)
  233.             if ($disciplineWarning->getQuarter() === $this) {
  234.                 $disciplineWarning->setQuarter(null);
  235.             }
  236.         }
  238.         return $this;
  239.     }
  241.     /**
  242.      * @return Collection<int, DisciplineRetained>
  243.      */
  244.     public function getDisciplineRetaineds(): Collection
  245.     {
  246.         return $this->disciplineRetaineds;
  247.     }
  249.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  250.     {
  251.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  252.             $this->disciplineRetaineds->add($disciplineRetained);
  253.             $disciplineRetained->setQuarter($this);
  254.         }
  256.         return $this;
  257.     }
  259.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  260.     {
  261.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  262.             // set the owning side to null (unless already changed)
  263.             if ($disciplineRetained->getQuarter() === $this) {
  264.                 $disciplineRetained->setQuarter(null);
  265.             }
  266.         }
  268.         return $this;
  269.     }
  271.     /**
  272.      * @return Collection<int, DisciplinePunish>
  273.      */
  274.     public function getDisciplinePunishes(): Collection
  275.     {
  276.         return $this->disciplinePunishes;
  277.     }
  279.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  280.     {
  281.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  282.             $this->disciplinePunishes->add($disciplinePunish);
  283.             $disciplinePunish->setQuarter($this);
  284.         }
  286.         return $this;
  287.     }
  289.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  290.     {
  291.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  292.             // set the owning side to null (unless already changed)
  293.             if ($disciplinePunish->getQuarter() === $this) {
  294.                 $disciplinePunish->setQuarter(null);
  295.             }
  296.         }
  298.         return $this;
  299.     }
  301.     public function getNameEn(): ?string
  302.     {
  303.         return $this->nameEn;
  304.     }
  306.     public function setNameEn(string $nameEn): static
  307.     {
  308.         $this->nameEn = $nameEn;
  310.         return $this;
  311.     }
  313.     public function getSlug(): ?string
  314.     {
  315.         return $this->slug;
  316.     }
  318.     public function setSlug(?string $slug): static
  319.     {
  320.         $this->slug = $slug;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, DisciplineConcile>
  327.      */
  328.     public function getDisciplineConciles(): Collection
  329.     {
  330.         return $this->disciplineConciles;
  331.     }
  333.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  334.     {
  335.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  336.             $this->disciplineConciles->add($disciplineConcile);
  337.             $disciplineConcile->setQuarter($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  344.     {
  345.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($disciplineConcile->getQuarter() === $this) {
  348.                 $disciplineConcile->setQuarter(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection<int, DisciplineExclusion>
  357.      */
  358.     public function getDisciplineExclusions(): Collection
  359.     {
  360.         return $this->disciplineExclusions;
  361.     }
  363.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  364.     {
  365.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  366.             $this->disciplineExclusions->add($disciplineExclusion);
  367.             $disciplineExclusion->setQuarter($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  374.     {
  375.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  376.             // set the owning side to null (unless already changed)
  377.             if ($disciplineExclusion->getQuarter() === $this) {
  378.                 $disciplineExclusion->setQuarter(null);
  379.             }
  380.         }
  382.         return $this;
  383.     }
  385.     public function getAgenda(): ?Agenda
  386.     {
  387.         return $this->agenda;
  388.     }
  390.     public function setAgenda(?Agenda $agenda): static
  391.     {
  392.         $this->agenda = $agenda;
  394.         return $this;
  395.     }
  396. }