src/Entity/Category.php line 12

1. <?php
3. namespace App\Entity;
5. use Doctrine\Common\Collections\ArrayCollection;
6. use Doctrine\Common\Collections\Collection;
7. use Doctrine\ORM\Mapping as ORM;
9. /**
10.  * @ORM\Entity(repositoryClass="App\Repository\CategoryRepository")
11.  */
12. class Category
13. {
14.     /**
15.      * @ORM\Id()
16.      * @ORM\GeneratedValue()
17.      * @ORM\Column(type="integer")
18.      */
19.     private $id;
21.     /**
22.      * @ORM\Column(type="string", length=50)
23.      */
24.     private $name;
27.     /**
28.      * @ORM\OneToMany(targetEntity="App\Entity\Subject", mappedBy="category")
29.      */
30.     private $subjects;
32.     /**
33.      * @ORM\ManyToMany(targetEntity="App\Entity\Teacher", mappedBy="categories")
34.      */
35.     private $teachers;
38.     /**
39.      * @ORM\OneToMany(targetEntity="App\Entity\Plan", mappedBy="category")
40.      */
41.     private $plans;
43.     /**
44.      * @ORM\OneToMany(targetEntity="App\Entity\SubscriptionOrder", mappedBy="category")
45.      */
46.     private $subscriptionOrders;
48.     /**
49.      * @ORM\Column(type="string", length=50)
50.      */
51.     private $nameEn;
53.     /**
54.      * @ORM\OneToMany(targetEntity="App\Entity\Ticket", mappedBy="category")
55.      */
56.     private $tickets;
58.     public function __construct()
59.     {
60.         $this->subjects = new ArrayCollection();
61.         $this->teachers = new ArrayCollection();
62.         $this->programs = new ArrayCollection();
63.         $this->plans = new ArrayCollection();
64.         $this->subscriptionOrders = new ArrayCollection();
65.         $this->tickets = new ArrayCollection();
66.     }
68.     public function getId(): ?int
69.     {
70.         return $this->id;
71.     }
73.     public function getName(): ?string
74.     {
75.         return $this->name;
76.     }
78.     public function setName(string $name): self
79.     {
80.         $this->name = $name;
82.         return $this;
83.     }
86.     /**
87.      * @return Collection|Subject[]
88.      */
89.     public function getSubjects(): Collection
90.     {
91.         return $this->subjects;
92.     }
94.     public function addSubject(Subject $subject): self
95.     {
96.         if (!$this->subjects->contains($subject)) {
97.             $this->subjects[] = $subject;
98.             $subject->setCategory($this);
99.         }
101.         return $this;
102.     }
104.     public function removeSubject(Subject $subject): self
105.     {
106.         if ($this->subjects->contains($subject)) {
107.             $this->subjects->removeElement($subject);
108.             // set the owning side to null (unless already changed)
109.             if ($subject->getCategory() === $this) {
110.                 $subject->setCategory(null);
111.             }
112.         }
114.         return $this;
115.     }
117.     public function __toString()
118.     {
119.     return $this->getName();
120.     }
122.     /**
123.      * @return Collection|Teacher[]
124.      */
125.     public function getTeachers(): Collection
126.     {
127.         return $this->teachers;
128.     }
130.     public function addTeacher(Teacher $teacher): self
131.     {
132.         if (!$this->teachers->contains($teacher)) {
133.             $this->teachers[] = $teacher;
134.             $teacher->addCategory($this);
135.         }
137.         return $this;
138.     }
140.     public function removeTeacher(Teacher $teacher): self
141.     {
142.         if ($this->teachers->contains($teacher)) {
143.             $this->teachers->removeElement($teacher);
144.             $teacher->removeCategory($this);
145.         }
147.         return $this;
148.     }
151.     /**
152.      * @return Collection|Plan[]
153.      */
154.     public function getPlans(): Collection
155.     {
156.         return $this->plans;
157.     }
159.     public function addPlan(Plan $plan): self
160.     {
161.         if (!$this->plans->contains($plan)) {
162.             $this->plans[] = $plan;
163.             $plan->setCategory($this);
164.         }
166.         return $this;
167.     }
169.     public function removePlan(Plan $plan): self
170.     {
171.         if ($this->plans->contains($plan)) {
172.             $this->plans->removeElement($plan);
173.             // set the owning side to null (unless already changed)
174.             if ($plan->getCategory() === $this) {
175.                 $plan->setCategory(null);
176.             }
177.         }
179.         return $this;
180.     }
182.     /**
183.      * @return Collection|SubscriptionOrder[]
184.      */
185.     public function getSubscriptionOrders(): Collection
186.     {
187.         return $this->subscriptionOrders;
188.     }
190.     public function addSubscriptionOrder(SubscriptionOrder $subscriptionOrder): self
191.     {
192.         if (!$this->subscriptionOrders->contains($subscriptionOrder)) {
193.             $this->subscriptionOrders[] = $subscriptionOrder;
194.             $subscriptionOrder->setCategory($this);
195.         }
197.         return $this;
198.     }
200.     public function removeSubscriptionOrder(SubscriptionOrder $subscriptionOrder): self
201.     {
202.         if ($this->subscriptionOrders->contains($subscriptionOrder)) {
203.             $this->subscriptionOrders->removeElement($subscriptionOrder);
204.             // set the owning side to null (unless already changed)
205.             if ($subscriptionOrder->getCategory() === $this) {
206.                 $subscriptionOrder->setCategory(null);
207.             }
208.         }
210.         return $this;
211.     }
213.     public function getNameEn(): ?string
214.     {
215.         return $this->nameEn;
216.     }
218.     public function setNameEn(?string $nameEn): self
219.     {
220.         $this->nameEn = $nameEn;
222.         return $this;
223.     }
225.     /**
226.      * @return Collection|Ticket[]
227.      */
228.     public function getTickets(): Collection
229.     {
230.         return $this->tickets;
231.     }
233.     public function addTicket(Ticket $ticket): self
234.     {
235.         if (!$this->tickets->contains($ticket)) {
236.             $this->tickets[] = $ticket;
237.             $ticket->setCategory($this);
238.         }
240.         return $this;
241.     }
243.     public function removeTicket(Ticket $ticket): self
244.     {
245.         if ($this->tickets->contains($ticket)) {
246.             $this->tickets->removeElement($ticket);
247.             // set the owning side to null (unless already changed)
248.             if ($ticket->getCategory() === $this) {
249.                 $ticket->setCategory(null);
250.             }
251.         }
253.         return $this;
254.     }
255. }