src/Entity/Lesson.php line 12

1. <?php
3. namespace App\Entity;
5. use App\Entity\Traits\Sortable;
6. use App\Repository\LessonRepository;
7. use Doctrine\Common\Collections\ArrayCollection;
8. use Doctrine\Common\Collections\Collection;
9. use Doctrine\ORM\Mapping as ORM;
11. #[ORM\Entity(repositoryClass: LessonRepository::class)]
12. class Lesson
13. {
14.     use Sortable;
16.     #[ORM\Id]
17.     #[ORM\GeneratedValue]
18.     #[ORM\Column(type: 'integer')]
19.     private $id;
21.     #[ORM\Column(type: 'string', length: 100)]
22.     private $name;
24.     #[ORM\Column(type: 'string', length: 10)]
25.     private $acronym;
27.     #[ORM\Column(type: 'date_immutable', nullable: true)]
28.     private $yearMin;
30.     #[ORM\Column(type: 'date_immutable', nullable: true)]
31.     private $yearMax;
33.     #[ORM\Column(type: 'smallint', nullable: true)]
34.     private $price;
36.     #[ORM\Column(type: 'smallint')]
37.     private $minSlot = 1;
39.     #[ORM\Column(type: 'smallint')]
40.     private $maxSlot = 1;
42.     #[ORM\ManyToOne(targetEntity: Season::class, inversedBy: 'lessons')]
43.     #[ORM\JoinColumn(nullable: false)]
44.     private $season;
46.     #[ORM\ManyToMany(targetEntity: Slot::class, mappedBy: 'lessons')]
47.     private $slots;
49.     #[ORM\OneToMany(targetEntity: Registration::class, mappedBy: 'lesson')]
50.     private $registrations;
52.     #[ORM\OneToMany(mappedBy: 'lesson', targetEntity: CartItemLesson::class)]
53.     private $cartItemLessons;
55.     public function __construct()
56.     {
57.         $this->slots = new ArrayCollection();
58.         $this->registrations = new ArrayCollection();
59.         $this->cartItemLessons = new ArrayCollection();
60.     }
62.     public function __toString(): string
63.     {
64.         return $this->getName();
65.     }
67.     public function getId(): ?int
68.     {
69.         return $this->id;
70.     }
72.     public function getName($full = false): ?string
73.     {
74.         if ($full) {
75.             return sprintf('[%s] %s', $this->getAcronym(), $this->name);
76.         }
78.         return $this->name;
79.     }
81.     public function setName(string $name): self
82.     {
83.         $this->name = $name;
85.         return $this;
86.     }
88.     public function getAcronym(): ?string
89.     {
90.         return $this->acronym;
91.     }
93.     public function setAcronym(string $acronym): self
94.     {
95.         $this->acronym = $acronym;
97.         return $this;
98.     }
100.     public function getYearMin(): ?\DateTimeImmutable
101.     {
102.         return $this->yearMin;
103.     }
105.     public function setYearMin(?\DateTimeImmutable $yearMin): self
106.     {
107.         $this->yearMin = $yearMin;
109.         return $this;
110.     }
112.     public function getYearMax(): ?\DateTimeImmutable
113.     {
114.         return $this->yearMax;
115.     }
117.     public function setYearMax(?\DateTimeImmutable $yearMax): self
118.     {
119.         $this->yearMax = $yearMax;
121.         return $this;
122.     }
124.     public function getPrice(): ?int
125.     {
126.         return $this->price ?? 0;
127.     }
129.     public function setPrice(?int $price): self
130.     {
131.         $this->price = $price;
133.         return $this;
134.     }
136.     public function getMinSlot(): ?int
137.     {
138.         return $this->minSlot;
139.     }
141.     public function setMinSlot(int $minSlot): self
142.     {
143.         $this->minSlot = $minSlot;
145.         return $this;
146.     }
148.     public function getMaxSlot(): ?int
149.     {
150.         return $this->maxSlot;
151.     }
153.     public function setMaxSlot(int $maxSlot): self
154.     {
155.         $this->maxSlot = $maxSlot;
157.         return $this;
158.     }
160.     public function getSeason(): ?Season
161.     {
162.         return $this->season;
163.     }
165.     public function setSeason(?Season $season): self
166.     {
167.         $this->season = $season;
169.         return $this;
170.     }
172.     /**
173.      * @return Collection<int, Slot>
174.      */
175.     public function getSlots(): Collection
176.     {
177.         return $this->slots;
178.     }
180.     public function addSlot(Slot $slot): self
181.     {
182.         if (!$this->slots->contains($slot)) {
183.             $this->slots[] = $slot;
184.             $slot->addLesson($this);
185.         }
187.         return $this;
188.     }
190.     public function removeSlot(Slot $slot): self
191.     {
192.         if ($this->slots->removeElement($slot)) {
193.             $slot->removeLesson($this);
194.         }
196.         return $this;
197.     }
199.     /**
200.      * @return Collection<int, Registration>
201.      */
202.     public function getRegistrations(): Collection
203.     {
204.         return $this->registrations;
205.     }
207.     public function addRegistration(Registration $registration): self
208.     {
209.         if (!$this->registrations->contains($registration)) {
210.             $this->registrations[] = $registration;
211.         }
213.         return $this;
214.     }
216.     public function removeRegistration(Registration $registration): self
217.     {
218.         $this->registrations->removeElement($registration);
220.         return $this;
221.     }
223.     /**
224.      * @return Collection<int, CartItemLesson>
225.      */
226.     public function getCartItemLessons(): Collection
227.     {
228.         return $this->cartItemLessons;
229.     }
231.     public function addCartItemLesson(CartItemLesson $cartItemLesson): self
232.     {
233.         if (!$this->cartItemLessons->contains($cartItemLesson)) {
234.             $this->cartItemLessons[] = $cartItemLesson;
235.             $cartItemLesson->setLesson($this);
236.         }
238.         return $this;
239.     }
241.     public function removeCartItemLesson(CartItemLesson $cartItemLesson): self
242.     {
243.         if ($this->cartItemLessons->removeElement($cartItemLesson)) {
244.             // set the owning side to null (unless already changed)
245.             if ($cartItemLesson->getLesson() === $this) {
246.                 $cartItemLesson->setLesson(null);
247.             }
248.         }
250.         return $this;
251.     }
253.     public function __clone()
254.     {
255.         $this->id = null;
256.         $this->season = null;
257.         $this->slots = new ArrayCollection();
258.         $this->registrations = new ArrayCollection();
259.         $this->cartItemLessons = new ArrayCollection();
261.         $yearMin = \DateTime::createFromImmutable($this->yearMin);
262.         $yearMax = \DateTime::createFromImmutable($this->yearMax);
263.         $yearMin->add(new \DateInterval('P1Y'));
264.         $yearMax->add(new \DateInterval('P1Y'));
265.         $this->yearMin = \DateTimeImmutable::createFromMutable($yearMin);
266.         $this->yearMax = \DateTimeImmutable::createFromMutable($yearMax);
267.     }
268. }