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(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', '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.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  37.     private ?SchoolYear $year = null;
  39.     #[ORM\ManyToOne(inversedBy: 'quarters', cascade: ["persist"])]
  40.     #[ORM\JoinColumn(nullable: false)]
  41.     private ?User $author = null;
  43.     #[ORM\ManyToOne(inversedBy: 'quarter')]
  44.     #[ORM\JoinColumn(nullable: true)]
  45.     private ?GlobalQuarter $globalQuarter = null;
  47.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineBlame::class)]
  48.     private Collection $disciplineBlames;
  50.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineWarning::class)]
  51.     private Collection $disciplineWarnings;
  53.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineRetained::class)]
  54.     private Collection $disciplineRetaineds;
  56.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplinePunish::class)]
  57.     private Collection $disciplinePunishes;
  59.     #[ORM\Column(length: 255)]
  60.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  61.     private ?string $nameEn = null;
  63.     #[ORM\Column(length: 255, nullable: true)]
  64.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  65.     private ?string $slug = null;
  67.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineConcile::class)]
  68.     private Collection $disciplineConciles;
  70.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineExclusion::class)]
  71.     private Collection $disciplineExclusions;
  73.     #[ORM\ManyToOne(inversedBy: 'quarter')]
  74.     private ?Agenda $agenda = null;
  76.     public function __construct()
  77.     {
  78.         $this->exams = new ArrayCollection();
  79.         $this->disciplineBlames = new ArrayCollection();
  80.         $this->disciplineWarnings = new ArrayCollection();
  81.         $this->disciplineRetaineds = new ArrayCollection();
  82.         $this->disciplinePunishes = new ArrayCollection();
  83.         $this->disciplineConciles = new ArrayCollection();
  84.         $this->disciplineExclusions = new ArrayCollection();
  85.     }
  87.     public function getId(): ?int
  88.     {
  89.         return $this->id;
  90.     }
  92.     public function getName(): ?string
  93.     {
  94.         return $this->name;
  95.     }
  97.     public function setName(string $name): static
  98.     {
  99.         $this->name = $name;
  101.         return $this;
  102.     }
  104.     public function getCoef(): ?float
  105.     {
  106.         return $this->coef;
  107.     }
  109.     public function setCoef(?float $coef): static
  110.     {
  111.         $this->coef = $coef;
  113.         return $this;
  114.     }
  116.     /**
  117.      * @return Collection<int, Exams>
  118.      */
  119.     public function getExams(): Collection
  120.     {
  121.         return $this->exams;
  122.     }
  124.     public function addExam(Exams $exam): static
  125.     {
  126.         if (!$this->exams->contains($exam)) {
  127.             $this->exams->add($exam);
  128.             $exam->setQuarter($this);
  129.         }
  131.         return $this;
  132.     }
  134.     public function removeExam(Exams $exam): static
  135.     {
  136.         if ($this->exams->removeElement($exam)) {
  137.             // set the owning side to null (unless already changed)
  138.             if ($exam->getQuarter() === $this) {
  139.                 $exam->setQuarter(null);
  140.             }
  141.         }
  143.         return $this;
  144.     }
  146.     public function getYear(): ?SchoolYear
  147.     {
  148.         return $this->year;
  149.     }
  151.     public function setYear(?SchoolYear $year): static
  152.     {
  153.         $this->year = $year;
  155.         return $this;
  156.     }
  158.     public function getAuthor(): ?User
  159.     {
  160.         return $this->author;
  161.     }
  163.     public function setAuthor(?User $author): static
  164.     {
  165.         $this->author = $author;
  167.         return $this;
  168.     }
  170.     public function getGlobalQuarter(): ?GlobalQuarter
  171.     {
  172.         return $this->globalQuarter;
  173.     }
  175.     public function setGlobalQuarter(?GlobalQuarter $globalQuarter): static
  176.     {
  177.         $this->globalQuarter = $globalQuarter;
  179.         return $this;
  180.     }
  182.     /**
  183.      * @return Collection<int, DisciplineBlame>
  184.      */
  185.     public function getDisciplineBlames(): Collection
  186.     {
  187.         return $this->disciplineBlames;
  188.     }
  190.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  191.     {
  192.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  193.             $this->disciplineBlames->add($disciplineBlame);
  194.             $disciplineBlame->setQuarter($this);
  195.         }
  197.         return $this;
  198.     }
  200.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  201.     {
  202.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  203.             // set the owning side to null (unless already changed)
  204.             if ($disciplineBlame->getQuarter() === $this) {
  205.                 $disciplineBlame->setQuarter(null);
  206.             }
  207.         }
  209.         return $this;
  210.     }
  212.     /**
  213.      * @return Collection<int, DisciplineWarning>
  214.      */
  215.     public function getDisciplineWarnings(): Collection
  216.     {
  217.         return $this->disciplineWarnings;
  218.     }
  220.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  221.     {
  222.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  223.             $this->disciplineWarnings->add($disciplineWarning);
  224.             $disciplineWarning->setQuarter($this);
  225.         }
  227.         return $this;
  228.     }
  230.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  231.     {
  232.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  233.             // set the owning side to null (unless already changed)
  234.             if ($disciplineWarning->getQuarter() === $this) {
  235.                 $disciplineWarning->setQuarter(null);
  236.             }
  237.         }
  239.         return $this;
  240.     }
  242.     /**
  243.      * @return Collection<int, DisciplineRetained>
  244.      */
  245.     public function getDisciplineRetaineds(): Collection
  246.     {
  247.         return $this->disciplineRetaineds;
  248.     }
  250.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  251.     {
  252.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  253.             $this->disciplineRetaineds->add($disciplineRetained);
  254.             $disciplineRetained->setQuarter($this);
  255.         }
  257.         return $this;
  258.     }
  260.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  261.     {
  262.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  263.             // set the owning side to null (unless already changed)
  264.             if ($disciplineRetained->getQuarter() === $this) {
  265.                 $disciplineRetained->setQuarter(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     /**
  273.      * @return Collection<int, DisciplinePunish>
  274.      */
  275.     public function getDisciplinePunishes(): Collection
  276.     {
  277.         return $this->disciplinePunishes;
  278.     }
  280.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  281.     {
  282.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  283.             $this->disciplinePunishes->add($disciplinePunish);
  284.             $disciplinePunish->setQuarter($this);
  285.         }
  287.         return $this;
  288.     }
  290.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  291.     {
  292.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  293.             // set the owning side to null (unless already changed)
  294.             if ($disciplinePunish->getQuarter() === $this) {
  295.                 $disciplinePunish->setQuarter(null);
  296.             }
  297.         }
  299.         return $this;
  300.     }
  302.     public function getNameEn(): ?string
  303.     {
  304.         return $this->nameEn;
  305.     }
  307.     public function setNameEn(string $nameEn): static
  308.     {
  309.         $this->nameEn = $nameEn;
  311.         return $this;
  312.     }
  314.     public function getSlug(): ?string
  315.     {
  316.         return $this->slug;
  317.     }
  319.     public function setSlug(?string $slug): static
  320.     {
  321.         $this->slug = $slug;
  323.         return $this;
  324.     }
  326.     /**
  327.      * @return Collection<int, DisciplineConcile>
  328.      */
  329.     public function getDisciplineConciles(): Collection
  330.     {
  331.         return $this->disciplineConciles;
  332.     }
  334.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  335.     {
  336.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  337.             $this->disciplineConciles->add($disciplineConcile);
  338.             $disciplineConcile->setQuarter($this);
  339.         }
  341.         return $this;
  342.     }
  344.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  345.     {
  346.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($disciplineConcile->getQuarter() === $this) {
  349.                 $disciplineConcile->setQuarter(null);
  350.             }
  351.         }
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection<int, DisciplineExclusion>
  358.      */
  359.     public function getDisciplineExclusions(): Collection
  360.     {
  361.         return $this->disciplineExclusions;
  362.     }
  364.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  365.     {
  366.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  367.             $this->disciplineExclusions->add($disciplineExclusion);
  368.             $disciplineExclusion->setQuarter($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  375.     {
  376.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($disciplineExclusion->getQuarter() === $this) {
  379.                 $disciplineExclusion->setQuarter(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     public function getAgenda(): ?Agenda
  387.     {
  388.         return $this->agenda;
  389.     }
  391.     public function setAgenda(?Agenda $agenda): static
  392.     {
  393.         $this->agenda = $agenda;
  395.         return $this;
  396.     }
  397. }