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'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['getExamStudent'])]
  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 ?TheClass $classe = null;
  38.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'quarters')]
  39.     #[ORM\JoinColumn(nullable: false)]
  40.     private ?School $school = null;
  42.     #[ORM\ManyToOne(inversedBy: 'quarters', cascade: ["persist"])]
  43.     #[ORM\JoinColumn(nullable: false)]
  44.     private ?SchoolYear $year = null;
  46.     #[ORM\ManyToOne(inversedBy: 'quarters', cascade: ["persist"])]
  47.     #[ORM\JoinColumn(nullable: false)]
  48.     private ?User $author = null;
  50.     #[ORM\ManyToOne(inversedBy: 'quarter')]
  51.     #[ORM\JoinColumn(nullable: true)]
  52.     private ?GlobalQuarter $globalQuarter = null;
  54.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineBlame::class)]
  55.     private Collection $disciplineBlames;
  57.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineWarning::class)]
  58.     private Collection $disciplineWarnings;
  60.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineRetained::class)]
  61.     private Collection $disciplineRetaineds;
  63.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplinePunish::class)]
  64.     private Collection $disciplinePunishes;
  66.     #[ORM\Column(length: 255)]
  67.     private ?string $nameEn = null;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $slug = null;
  72.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineConcile::class)]
  73.     private Collection $disciplineConciles;
  75.     #[ORM\OneToMany(mappedBy: 'quarter', targetEntity: DisciplineExclusion::class)]
  76.     private Collection $disciplineExclusions;
  78.     public function __construct()
  79.     {
  80.         $this->exams = new ArrayCollection();
  81.         $this->disciplineBlames = new ArrayCollection();
  82.         $this->disciplineWarnings = new ArrayCollection();
  83.         $this->disciplineRetaineds = new ArrayCollection();
  84.         $this->disciplinePunishes = new ArrayCollection();
  85.         $this->disciplineConciles = new ArrayCollection();
  86.         $this->disciplineExclusions = new ArrayCollection();
  87.     }
  89.     public function getId(): ?int
  90.     {
  91.         return $this->id;
  92.     }
  94.     public function getName(): ?string
  95.     {
  96.         return $this->name;
  97.     }
  99.     public function setName(string $name): static
  100.     {
  101.         $this->name = $name;
  103.         return $this;
  104.     }
  106.     public function getCoef(): ?float
  107.     {
  108.         return $this->coef;
  109.     }
  111.     public function setCoef(?float $coef): static
  112.     {
  113.         $this->coef = $coef;
  115.         return $this;
  116.     }
  118.     /**
  119.      * @return Collection<int, Exams>
  120.      */
  121.     public function getExams(): Collection
  122.     {
  123.         return $this->exams;
  124.     }
  126.     public function addExam(Exams $exam): static
  127.     {
  128.         if (!$this->exams->contains($exam)) {
  129.             $this->exams->add($exam);
  130.             $exam->setQuarter($this);
  131.         }
  133.         return $this;
  134.     }
  136.     public function removeExam(Exams $exam): static
  137.     {
  138.         if ($this->exams->removeElement($exam)) {
  139.             // set the owning side to null (unless already changed)
  140.             if ($exam->getQuarter() === $this) {
  141.                 $exam->setQuarter(null);
  142.             }
  143.         }
  145.         return $this;
  146.     }
  148.     public function getClasse(): ?TheClass
  149.     {
  150.         return $this->classe;
  151.     }
  153.     public function setClasse(?TheClass $classe): static
  154.     {
  155.         $this->classe = $classe;
  157.         return $this;
  158.     }
  160.     public function getSchool(): ?School
  161.     {
  162.         return $this->school;
  163.     }
  165.     public function setSchool(?School $school): static
  166.     {
  167.         $this->school = $school;
  169.         return $this;
  170.     }
  172.     public function getYear(): ?SchoolYear
  173.     {
  174.         return $this->year;
  175.     }
  177.     public function setYear(?SchoolYear $year): static
  178.     {
  179.         $this->year = $year;
  181.         return $this;
  182.     }
  184.     public function getAuthor(): ?User
  185.     {
  186.         return $this->author;
  187.     }
  189.     public function setAuthor(?User $author): static
  190.     {
  191.         $this->author = $author;
  193.         return $this;
  194.     }
  196.     public function getGlobalQuarter(): ?GlobalQuarter
  197.     {
  198.         return $this->globalQuarter;
  199.     }
  201.     public function setGlobalQuarter(?GlobalQuarter $globalQuarter): static
  202.     {
  203.         $this->globalQuarter = $globalQuarter;
  205.         return $this;
  206.     }
  208.     /**
  209.      * @return Collection<int, DisciplineBlame>
  210.      */
  211.     public function getDisciplineBlames(): Collection
  212.     {
  213.         return $this->disciplineBlames;
  214.     }
  216.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  217.     {
  218.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  219.             $this->disciplineBlames->add($disciplineBlame);
  220.             $disciplineBlame->setQuarter($this);
  221.         }
  223.         return $this;
  224.     }
  226.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  227.     {
  228.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  229.             // set the owning side to null (unless already changed)
  230.             if ($disciplineBlame->getQuarter() === $this) {
  231.                 $disciplineBlame->setQuarter(null);
  232.             }
  233.         }
  235.         return $this;
  236.     }
  238.     /**
  239.      * @return Collection<int, DisciplineWarning>
  240.      */
  241.     public function getDisciplineWarnings(): Collection
  242.     {
  243.         return $this->disciplineWarnings;
  244.     }
  246.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  247.     {
  248.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  249.             $this->disciplineWarnings->add($disciplineWarning);
  250.             $disciplineWarning->setQuarter($this);
  251.         }
  253.         return $this;
  254.     }
  256.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  257.     {
  258.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  259.             // set the owning side to null (unless already changed)
  260.             if ($disciplineWarning->getQuarter() === $this) {
  261.                 $disciplineWarning->setQuarter(null);
  262.             }
  263.         }
  265.         return $this;
  266.     }
  268.     /**
  269.      * @return Collection<int, DisciplineRetained>
  270.      */
  271.     public function getDisciplineRetaineds(): Collection
  272.     {
  273.         return $this->disciplineRetaineds;
  274.     }
  276.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  277.     {
  278.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  279.             $this->disciplineRetaineds->add($disciplineRetained);
  280.             $disciplineRetained->setQuarter($this);
  281.         }
  283.         return $this;
  284.     }
  286.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  287.     {
  288.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  289.             // set the owning side to null (unless already changed)
  290.             if ($disciplineRetained->getQuarter() === $this) {
  291.                 $disciplineRetained->setQuarter(null);
  292.             }
  293.         }
  295.         return $this;
  296.     }
  298.     /**
  299.      * @return Collection<int, DisciplinePunish>
  300.      */
  301.     public function getDisciplinePunishes(): Collection
  302.     {
  303.         return $this->disciplinePunishes;
  304.     }
  306.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  307.     {
  308.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  309.             $this->disciplinePunishes->add($disciplinePunish);
  310.             $disciplinePunish->setQuarter($this);
  311.         }
  313.         return $this;
  314.     }
  316.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  317.     {
  318.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  319.             // set the owning side to null (unless already changed)
  320.             if ($disciplinePunish->getQuarter() === $this) {
  321.                 $disciplinePunish->setQuarter(null);
  322.             }
  323.         }
  325.         return $this;
  326.     }
  328.     public function getNameEn(): ?string
  329.     {
  330.         return $this->nameEn;
  331.     }
  333.     public function setNameEn(string $nameEn): static
  334.     {
  335.         $this->nameEn = $nameEn;
  337.         return $this;
  338.     }
  340.     public function getSlug(): ?string
  341.     {
  342.         return $this->slug;
  343.     }
  345.     public function setSlug(?string $slug): static
  346.     {
  347.         $this->slug = $slug;
  349.         return $this;
  350.     }
  352.     /**
  353.      * @return Collection<int, DisciplineConcile>
  354.      */
  355.     public function getDisciplineConciles(): Collection
  356.     {
  357.         return $this->disciplineConciles;
  358.     }
  360.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  361.     {
  362.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  363.             $this->disciplineConciles->add($disciplineConcile);
  364.             $disciplineConcile->setQuarter($this);
  365.         }
  367.         return $this;
  368.     }
  370.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  371.     {
  372.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  373.             // set the owning side to null (unless already changed)
  374.             if ($disciplineConcile->getQuarter() === $this) {
  375.                 $disciplineConcile->setQuarter(null);
  376.             }
  377.         }
  379.         return $this;
  380.     }
  382.     /**
  383.      * @return Collection<int, DisciplineExclusion>
  384.      */
  385.     public function getDisciplineExclusions(): Collection
  386.     {
  387.         return $this->disciplineExclusions;
  388.     }
  390.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  391.     {
  392.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  393.             $this->disciplineExclusions->add($disciplineExclusion);
  394.             $disciplineExclusion->setQuarter($this);
  395.         }
  397.         return $this;
  398.     }
  400.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  401.     {
  402.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  403.             // set the owning side to null (unless already changed)
  404.             if ($disciplineExclusion->getQuarter() === $this) {
  405.                 $disciplineExclusion->setQuarter(null);
  406.             }
  407.         }
  409.         return $this;
  410.     }
  411. }