src/Entity/Season.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SeasonRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: SeasonRepository::class)]
  11. class Season
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column(type: 'integer')]
  16.     private $id;
  18.     #[ORM\Column(type: 'string', length: 50, nullable: true)]
  19.     private $name;
  21.     #[ORM\Column(type: 'date_immutable')]
  22.     private $startAt;
  24.     #[ORM\Column(type: 'date_immutable')]
  25.     private $endAt;
  27.     #[ORM\Column(type: 'boolean')]
  28.     private $isActive;
  30.     #[ORM\ManyToOne(targetEntity: GlobalSeason::class, inversedBy: 'seasons')]
  31.     #[ORM\JoinColumn(nullable: false)]
  32.     private $globalSeason;
  34.     #[ORM\OneToOne(inversedBy: 'nextSeason', targetEntity: self::class, cascade: ['persist'])]
  35.     private $previousSeason;
  37.     #[ORM\OneToOne(mappedBy: 'previousSeason', targetEntity: self::class, cascade: ['persist'])]
  38.     private $nextSeason;
  40.     #[ORM\ManyToOne(targetEntity: Section::class, inversedBy: 'seasons')]
  41.     #[ORM\JoinColumn(nullable: false)]
  42.     private $section;
  44.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Coach::class)]
  45.     private $coaches;
  47.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Lesson::class)]
  48.     private $lessons;
  50.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: DocumentModel::class)]
  51.     private $documentModels;
  53.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Registration::class)]
  54.     private $registrations;
  56.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Profiling::class)]
  57.     private $profilings;
  59.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: ProfilingPerson::class)]
  60.     private $profilingPersons;
  62.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Envelope::class)]
  63.     private $envelopes;
  65.     #[ORM\OneToMany(mappedBy: 'season', targetEntity: Slot::class)]
  66.     private $slots;
  68.     #[ORM\Column(type: 'boolean')]
  69.     private $migrated = false;
  71.     public function __construct()
  72.     {
  73.         $this->coaches = new ArrayCollection();
  74.         $this->lessons = new ArrayCollection();
  75.         $this->documentModels = new ArrayCollection();
  76.         $this->registrations = new ArrayCollection();
  77.         $this->profilings = new ArrayCollection();
  78.         $this->profilingPersons = new ArrayCollection();
  79.         $this->envelopes = new ArrayCollection();
  80.         $this->slots = new ArrayCollection();
  81.     }
  83.     public function getId(): ?int
  84.     {
  85.         return $this->id;
  86.     }
  88.     public function getSection(): ?Section
  89.     {
  90.         return $this->section;
  91.     }
  93.     public function setSection(?Section $section): self
  94.     {
  95.         $this->section = $section;
  97.         return $this;
  98.     }
  100.     public function getName(): ?string
  101.     {
  102.         if ($this->name) {
  103.             return $this->name;
  104.         }
  106.         if ($this->getStartAt() && $this->getEndAt()) {
  107.             return sprintf('%s-%s', $this->getStartAt()->format('Y'), $this->getEndAt()->format('Y'));
  108.         }
  110.         return null;
  111.     }
  113.     public function setName(?string $name): self
  114.     {
  115.         $this->name = $name;
  117.         return $this;
  118.     }
  120.     public function getStartAt(): ?\DateTimeImmutable
  121.     {
  122.         return $this->startAt;
  123.     }
  125.     public function setStartAt(\DateTimeImmutable $startAt): self
  126.     {
  127.         $this->startAt = $startAt;
  129.         return $this;
  130.     }
  132.     public function getEndAt(): ?\DateTimeImmutable
  133.     {
  134.         return $this->endAt;
  135.     }
  137.     public function setEndAt(\DateTimeImmutable $endAt): self
  138.     {
  139.         $this->endAt = $endAt;
  141.         return $this;
  142.     }
  144.     public function getIsActive(): ?bool
  145.     {
  146.         return $this->isActive;
  147.     }
  149.     public function setIsActive(bool $isActive): self
  150.     {
  151.         $this->isActive = $isActive;
  153.         return $this;
  154.     }
  156.     public function getGlobalSeason(): ?GlobalSeason
  157.     {
  158.         return $this->globalSeason;
  159.     }
  161.     public function setGlobalSeason(?GlobalSeason $globalSeason): self
  162.     {
  163.         $this->globalSeason = $globalSeason;
  165.         return $this;
  166.     }
  168.     public function getPreviousSeason(): ?self
  169.     {
  170.         return $this->previousSeason;
  171.     }
  173.     public function setPreviousSeason(?self $previousSeason): self
  174.     {
  175.         $this->previousSeason = $previousSeason;
  177.         return $this;
  178.     }
  180.     public function getNextSeason(): ?self
  181.     {
  182.         return $this->nextSeason;
  183.     }
  185.     public function setNextSeason(?self $nextSeason): self
  186.     {
  187.         // unset the owning side of the relation if necessary
  188.         if ($nextSeason === null && $this->nextSeason !== null) {
  189.             $this->nextSeason->setPreviousSeason(null);
  190.         }
  192.         // set the owning side of the relation if necessary
  193.         if ($nextSeason !== null && $nextSeason->getPreviousSeason() !== $this) {
  194.             $nextSeason->setPreviousSeason($this);
  195.         }
  197.         $this->nextSeason = $nextSeason;
  199.         return $this;
  200.     }
  202.     /**
  203.      * @return Collection<int, Coach>
  204.      */
  205.     public function getCoaches(): Collection
  206.     {
  207.         return $this->coaches;
  208.     }
  210.     public function addCoach(Coach $coach): self
  211.     {
  212.         if (!$this->coaches->contains($coach)) {
  213.             $this->coaches[] = $coach;
  214.             $coach->setSeason($this);
  215.         }
  217.         return $this;
  218.     }
  220.     public function removeCoach(Coach $coach): self
  221.     {
  222.         if ($this->coaches->removeElement($coach)) {
  223.             // set the owning side to null (unless already changed)
  224.             if ($coach->getSeason() === $this) {
  225.                 $coach->setSeason(null);
  226.             }
  227.         }
  229.         return $this;
  230.     }
  232.     /**
  233.      * @return Collection<int, Lesson>
  234.      */
  235.     public function getLessons(): Collection
  236.     {
  237.         return $this->lessons;
  238.     }
  240.     public function addLesson(Lesson $lesson): self
  241.     {
  242.         if (!$this->lessons->contains($lesson)) {
  243.             $this->lessons[] = $lesson;
  244.             $lesson->setSeason($this);
  245.         }
  247.         return $this;
  248.     }
  250.     public function removeLesson(Lesson $lesson): self
  251.     {
  252.         if ($this->lessons->removeElement($lesson)) {
  253.             // set the owning side to null (unless already changed)
  254.             if ($lesson->getSeason() === $this) {
  255.                 $lesson->setSeason(null);
  256.             }
  257.         }
  259.         return $this;
  260.     }
  262.     /**
  263.      * @param bool|null $includeDiscounts
  264.      * @return Collection<int, DocumentModel>
  265.      */
  266.     public function getDocumentModels(?bool $includeDiscounts = true): Collection
  267.     {
  268.         if (false === $includeDiscounts) {
  269.             return $this->documentModels->filter(fn(DocumentModel $d) => $d->getDiscountModel() === null);
  270.         }
  272.         return $this->documentModels;
  273.     }
  275.     public function addDocumentModel(DocumentModel $documentModel): self
  276.     {
  277.         if (!$this->documentModels->contains($documentModel)) {
  278.             $this->documentModels[] = $documentModel;
  279.             $documentModel->setSeason($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeDocumentModel(DocumentModel $documentModel): self
  286.     {
  287.         if ($this->documentModels->removeElement($documentModel)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($documentModel->getSeason() === $this) {
  290.                 $documentModel->setSeason(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     public function __toString(): string
  298.     {
  299.         return sprintf(
  300.             '%s %s - %s (%s)',
  301.             $this->getSection()?->getName(),
  302.             $this->getStartAt()?->format('d/m/Y'),
  303.             $this->getEndAt()?->format('d/m/Y'),
  304.             $this->name ?? 'N/A',
  305.         );
  306.     }
  308.     /**
  309.      * @return Collection<int, Registration>
  310.      */
  311.     public function getRegistrations(): Collection
  312.     {
  313.         return $this->registrations;
  314.     }
  316.     public function addRegistration(Registration $registration): self
  317.     {
  318.         if (!$this->registrations->contains($registration)) {
  319.             $this->registrations[] = $registration;
  320.             $registration->setSeason($this);
  321.         }
  323.         return $this;
  324.     }
  326.     public function removeRegistration(Registration $registration): self
  327.     {
  328.         if ($this->registrations->removeElement($registration)) {
  329.             // set the owning side to null (unless already changed)
  330.             if ($registration->getSeason() === $this) {
  331.                 $registration->setSeason(null);
  332.             }
  333.         }
  335.         return $this;
  336.     }
  338.     /**
  339.      * @return Collection<int, Profiling>
  340.      */
  341.     public function getProfilings(): Collection
  342.     {
  343.         return $this->profilings;
  344.     }
  346.     public function addProfiling(Profiling $profiling): self
  347.     {
  348.         if (!$this->profilings->contains($profiling)) {
  349.             $this->profilings[] = $profiling;
  350.             $profiling->setSeason($this);
  351.         }
  353.         return $this;
  354.     }
  356.     public function removeProfiling(Profiling $profiling): self
  357.     {
  358.         if ($this->profilings->removeElement($profiling)) {
  359.             // set the owning side to null (unless already changed)
  360.             if ($profiling->getSeason() === $this) {
  361.                 $profiling->setSeason(null);
  362.             }
  363.         }
  365.         return $this;
  366.     }
  368.     /**
  369.      * @return Collection<int, ProfilingPerson>
  370.      */
  371.     public function getProfilingPersons(): Collection
  372.     {
  373.         return $this->profilingPersons;
  374.     }
  376.     public function addProfilingPerson(ProfilingPerson $profilingPerson): self
  377.     {
  378.         if (!$this->profilingPersons->contains($profilingPerson)) {
  379.             $this->profilingPersons[] = $profilingPerson;
  380.             $profilingPerson->setSeason($this);
  381.         }
  383.         return $this;
  384.     }
  386.     public function removeProfilingPerson(ProfilingPerson $profilingPerson): self
  387.     {
  388.         if ($this->profilingPersons->removeElement($profilingPerson)) {
  389.             // set the owning side to null (unless already changed)
  390.             if ($profilingPerson->getSeason() === $this) {
  391.                 $profilingPerson->setSeason(null);
  392.             }
  393.         }
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, Envelope>
  400.      */
  401.     public function getEnvelopes(): Collection
  402.     {
  403.         return $this->envelopes;
  404.     }
  406.     public function addEnvelope(Envelope $envelope): self
  407.     {
  408.         if (!$this->envelopes->contains($envelope)) {
  409.             $this->envelopes[] = $envelope;
  410.             $envelope->setSeason($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeEnvelope(Envelope $envelope): self
  417.     {
  418.         if ($this->envelopes->removeElement($envelope)) {
  419.             // set the owning side to null (unless already changed)
  420.             if ($envelope->getSeason() === $this) {
  421.                 $envelope->setSeason(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return Collection<int, Slot>
  430.      */
  431.     public function getSlots(): Collection
  432.     {
  433.         return $this->slots;
  434.     }
  436.     public function addSlot(Slot $slot): self
  437.     {
  438.         if (!$this->slots->contains($slot)) {
  439.             $this->slots[] = $slot;
  440.             $slot->setSeason($this);
  441.         }
  443.         return $this;
  444.     }
  446.     public function removeSlot(Slot $slot): self
  447.     {
  448.         if ($this->slots->removeElement($slot)) {
  449.             // set the owning side to null (unless already changed)
  450.             if ($slot->getSeason() === $this) {
  451.                 $slot->setSeason(null);
  452.             }
  453.         }
  455.         return $this;
  456.     }
  458.     public function isMigrated(): ?bool
  459.     {
  460.         return $this->migrated;
  461.     }
  463.     public function setMigrated(bool $migrated): self
  464.     {
  465.         $this->migrated = $migrated;
  467.         return $this;
  468.     }
  469. }