src/Entity/Subject.php line 12

Open in your IDE?
  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\SubjectRepository")
  11. */
  12. class Subject
  13. {
  14. /**
  15. * @ORM\Id()
  16. * @ORM\GeneratedValue()
  17. * @ORM\Column(type="integer")
  18. */
  19. private $id;
  21. /**
  22. * @ORM\Column(type="string", length=100)
  23. */
  24. private $name;
  26. /**
  27. * @ORM\Column(type="string", length=255)
  28. */
  29. private $description;
  31. /**
  32. * @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="subjects")
  33. * @ORM\JoinColumn(nullable=false)
  34. */
  35. private $category;
  37. /**
  38. * @ORM\OneToMany(targetEntity="App\Entity\SubscriptionOrder", mappedBy="subject")
  39. */
  40. private $subscriptionOrders;
  42. /**
  43. * @ORM\Column(type="string", length=255)
  44. */
  45. private $nameEn;
  47. /**
  48. * @ORM\Column(type="string", length=255)
  49. */
  50. private $descriptionEn;
  52. /**
  53. * @ORM\OneToMany(targetEntity="App\Entity\SubjectLevel", mappedBy="subject")
  54. */
  55. private $subjectLevels;
  57. /**
  58. * @ORM\OneToMany(targetEntity="App\Entity\ProgramUrl", mappedBy="subject")
  59. */
  60. private $programUrls;
  62. /**
  63. * @ORM\OneToMany(targetEntity="App\Entity\TeacherSubject", mappedBy="subject")
  64. */
  65. private $teacherSubjects;
  67. /**
  68. * @ORM\Column(type="boolean", nullable=true)
  69. */
  70. private $isFree;
  72. /**
  73. * @ORM\Column(type="boolean", nullable=true)
  74. */
  75. private $hasLevel;
  77. /**
  78. * @ORM\Column(type="integer", nullable=true)
  79. */
  80. private $price;
  82. /**
  83. * @ORM\Column(type="boolean", nullable=true)
  84. */
  85. private $isPublic;
  87. /**
  88. * @ORM\Column(type="string", length=100, nullable=true)
  89. */
  90. private $tagName;
  92. /**
  93. * @ORM\OneToMany(targetEntity=LevelTest::class, mappedBy="subject")
  94. */
  95. private $levelTests;
  97. /**
  98. * @ORM\OneToMany(targetEntity=SessionRegistrationDate::class, mappedBy="subject")
  99. */
  100. private $sessionRegistrationDates;
  102. /**
  103. * @ORM\OneToMany(targetEntity=StripePlanForGroup::class, mappedBy="subject")
  104. */
  105. private $stripePlanForGroups;
  107. /**
  108. * @ORM\OneToMany(targetEntity=UserPlacementTest::class, mappedBy="subject")
  109. */
  110. private $userPlacementTests;
  112. /**
  113. * @ORM\OneToMany(targetEntity=Exam::class, mappedBy="program", orphanRemoval=true)
  114. */
  115. private $exams;
  117. /**
  118. * @ORM\OneToMany(targetEntity=TrainingReport::class, mappedBy="program")
  119. */
  120. private $trainingReports;
  122. /**
  123. * @ORM\OneToMany(targetEntity=Discount::class, mappedBy="subject")
  124. */
  125. private $discounts;
  127. /**
  128. * @ORM\Column(type="boolean", nullable=true)
  129. */
  130. private $isDefault;
  132. /**
  133. * @ORM\Column(type="boolean", nullable=true)
  134. */
  135. private $hasMidExam;
  137. /**
  138. * @ORM\Column(type="boolean", nullable=true)
  139. */
  140. private $hasEndExam;
  142. /**
  143. * @ORM\Column(type="boolean", nullable=true)
  144. */
  145. private $hasOralExam;
  147. /**
  148. * @ORM\OneToMany(targetEntity=TeacherLeveltest::class, mappedBy="subject")
  149. */
  150. private $teacherLeveltests;
  152. /**
  153. * @ORM\OneToMany(targetEntity=LevelTestAdvice::class, mappedBy="subject")
  154. */
  155. private $levelTestAdvice;
  158. public function __construct()
  159. {
  160. $this->teachers = new ArrayCollection();
  161. $this->subscriptionOrders = new ArrayCollection();
  162. $this->subjectLevels = new ArrayCollection();
  163. $this->programUrls = new ArrayCollection();
  164. $this->teacherSubjects = new ArrayCollection();
  165. $this->levelTests = new ArrayCollection();
  166. $this->sessionRegistrationDates = new ArrayCollection();
  167. $this->stripePlanForGroups = new ArrayCollection();
  168. $this->userPlacementTests = new ArrayCollection();
  169. $this->exams = new ArrayCollection();
  170. $this->trainingReports = new ArrayCollection();
  171. $this->discounts = new ArrayCollection();
  172. $this->teacherLeveltests = new ArrayCollection();
  173. $this->levelTestAdvice = new ArrayCollection();
  174. }
  176. public function getId(): ?int
  177. {
  178. return $this->id;
  179. }
  181. public function getName(): ?string
  182. {
  183. return $this->name;
  184. }
  186. public function setName(string $name): self
  187. {
  188. $this->name = $name;
  190. return $this;
  191. }
  193. public function getDescription(): ?string
  194. {
  195. return $this->description;
  196. }
  198. public function setDescription(string $description): self
  199. {
  200. $this->description = $description;
  202. return $this;
  203. }
  205. public function getCategory(): ?Category
  206. {
  207. return $this->category;
  208. }
  210. public function setCategory(?Category $category): self
  211. {
  212. $this->category = $category;
  214. return $this;
  215. }
  218. public function __toString()
  219. {
  220. return $this->getName();
  221. }
  223. /**
  224. * @return Collection|SubscriptionOrder[]
  225. */
  226. public function getSubscriptionOrders(): Collection
  227. {
  228. return $this->subscriptionOrders;
  229. }
  231. public function addSubscriptionOrder(SubscriptionOrder $subscriptionOrder): self
  232. {
  233. if (!$this->subscriptionOrders->contains($subscriptionOrder)) {
  234. $this->subscriptionOrders[] = $subscriptionOrder;
  235. $subscriptionOrder->setSubject($this);
  236. }
  238. return $this;
  239. }
  241. public function removeSubscriptionOrder(SubscriptionOrder $subscriptionOrder): self
  242. {
  243. if ($this->subscriptionOrders->contains($subscriptionOrder)) {
  244. $this->subscriptionOrders->removeElement($subscriptionOrder);
  245. // set the owning side to null (unless already changed)
  246. if ($subscriptionOrder->getSubject() === $this) {
  247. $subscriptionOrder->setSubject(null);
  248. }
  249. }
  251. return $this;
  252. }
  254. public function getNameEn(): ?string
  255. {
  256. return $this->nameEn;
  257. }
  259. public function setNameEn(?string $nameEn): self
  260. {
  261. $this->nameEn = $nameEn;
  263. return $this;
  264. }
  266. public function getDescriptionEn(): ?string
  267. {
  268. return $this->descriptionEn;
  269. }
  271. public function setDescriptionEn(?string $descriptionEn): self
  272. {
  273. $this->descriptionEn = $descriptionEn;
  275. return $this;
  276. }
  278. /**
  279. * @return Collection|SubjectLevel[]
  280. */
  281. public function getSubjectLevels(): Collection
  282. {
  283. return $this->subjectLevels;
  284. }
  286. public function addSubjectLevel(SubjectLevel $subjectLevel): self
  287. {
  288. if (!$this->subjectLevels->contains($subjectLevel)) {
  289. $this->subjectLevels[] = $subjectLevel;
  290. $subjectLevel->setSubject($this);
  291. }
  293. return $this;
  294. }
  296. public function removeSubjectLevel(SubjectLevel $subjectLevel): self
  297. {
  298. if ($this->subjectLevels->contains($subjectLevel)) {
  299. $this->subjectLevels->removeElement($subjectLevel);
  300. // set the owning side to null (unless already changed)
  301. if ($subjectLevel->getSubject() === $this) {
  302. $subjectLevel->setSubject(null);
  303. }
  304. }
  306. return $this;
  307. }
  309. /**
  310. * @return Collection|ProgramUrl[]
  311. */
  312. public function getProgramUrls(): Collection
  313. {
  314. return $this->programUrls;
  315. }
  317. public function addProgramUrl(ProgramUrl $programUrl): self
  318. {
  319. if (!$this->programUrls->contains($programUrl)) {
  320. $this->programUrls[] = $programUrl;
  321. $programUrl->setSubject($this);
  322. }
  324. return $this;
  325. }
  327. public function removeProgramUrl(ProgramUrl $programUrl): self
  328. {
  329. if ($this->programUrls->contains($programUrl)) {
  330. $this->programUrls->removeElement($programUrl);
  331. // set the owning side to null (unless already changed)
  332. if ($programUrl->getSubject() === $this) {
  333. $programUrl->setSubject(null);
  334. }
  335. }
  337. return $this;
  338. }
  340. /**
  341. * @return Collection|TeacherSubject[]
  342. */
  343. public function getTeacherSubjects(): Collection
  344. {
  345. return $this->teacherSubjects;
  346. }
  348. public function addTeacherSubject(TeacherSubject $teacherSubject): self
  349. {
  350. if (!$this->teacherSubjects->contains($teacherSubject)) {
  351. $this->teacherSubjects[] = $teacherSubject;
  352. $teacherSubject->setSubject($this);
  353. }
  355. return $this;
  356. }
  358. public function removeTeacherSubject(TeacherSubject $teacherSubject): self
  359. {
  360. if ($this->teacherSubjects->contains($teacherSubject)) {
  361. $this->teacherSubjects->removeElement($teacherSubject);
  362. // set the owning side to null (unless already changed)
  363. if ($teacherSubject->getSubject() === $this) {
  364. $teacherSubject->setSubject(null);
  365. }
  366. }
  368. return $this;
  369. }
  371. public function getIsFree(): ?bool
  372. {
  373. return $this->isFree;
  374. }
  376. public function setIsFree(?bool $isFree): self
  377. {
  378. $this->isFree = $isFree;
  380. return $this;
  381. }
  383. public function getHasLevel(): ?bool
  384. {
  385. return $this->hasLevel;
  386. }
  388. public function setHasLevel(?bool $hasLevel): self
  389. {
  390. $this->hasLevel = $hasLevel;
  392. return $this;
  393. }
  395. public function getPrice(): ?int
  396. {
  397. return $this->price;
  398. }
  400. public function setPrice(?int $price): self
  401. {
  402. $this->price = $price;
  404. return $this;
  405. }
  407. public function getIsPublic(): ?bool
  408. {
  409. return $this->isPublic;
  410. }
  412. public function setIsPublic(?bool $isPublic): self
  413. {
  414. $this->isPublic = $isPublic;
  416. return $this;
  417. }
  419. public function getTagName(): ?string
  420. {
  421. return $this->tagName;
  422. }
  424. public function setTagName(?string $tagName): self
  425. {
  426. $this->tagName = $tagName;
  428. return $this;
  429. }
  431. /**
  432. * @return Collection|LevelTest[]
  433. */
  434. public function getLevelTests(): Collection
  435. {
  436. return $this->levelTests;
  437. }
  439. public function addLevelTest(LevelTest $levelTest): self
  440. {
  441. if (!$this->levelTests->contains($levelTest)) {
  442. $this->levelTests[] = $levelTest;
  443. $levelTest->setSubject($this);
  444. }
  446. return $this;
  447. }
  449. public function removeLevelTest(LevelTest $levelTest): self
  450. {
  451. if ($this->levelTests->removeElement($levelTest)) {
  452. // set the owning side to null (unless already changed)
  453. if ($levelTest->getSubject() === $this) {
  454. $levelTest->setSubject(null);
  455. }
  456. }
  458. return $this;
  459. }
  461. /**
  462. * @return Collection|SessionRegistrationDate[]
  463. */
  464. public function getSessionRegistrationDates(): Collection
  465. {
  466. return $this->sessionRegistrationDates;
  467. }
  469. public function addSessionRegistrationDate(SessionRegistrationDate $sessionRegistrationDate): self
  470. {
  471. if (!$this->sessionRegistrationDates->contains($sessionRegistrationDate)) {
  472. $this->sessionRegistrationDates[] = $sessionRegistrationDate;
  473. $sessionRegistrationDate->setSubject($this);
  474. }
  476. return $this;
  477. }
  479. public function removeSessionRegistrationDate(SessionRegistrationDate $sessionRegistrationDate): self
  480. {
  481. if ($this->sessionRegistrationDates->removeElement($sessionRegistrationDate)) {
  482. // set the owning side to null (unless already changed)
  483. if ($sessionRegistrationDate->getSubject() === $this) {
  484. $sessionRegistrationDate->setSubject(null);
  485. }
  486. }
  488. return $this;
  489. }
  491. /**
  492. * @return Collection|StripePlanForGroup[]
  493. */
  494. public function getStripePlanForGroups(): Collection
  495. {
  496. return $this->stripePlanForGroups;
  497. }
  499. public function addStripePlanForGroup(StripePlanForGroup $stripePlanForGroup): self
  500. {
  501. if (!$this->stripePlanForGroups->contains($stripePlanForGroup)) {
  502. $this->stripePlanForGroups[] = $stripePlanForGroup;
  503. $stripePlanForGroup->setSubject($this);
  504. }
  506. return $this;
  507. }
  509. public function removeStripePlanForGroup(StripePlanForGroup $stripePlanForGroup): self
  510. {
  511. if ($this->stripePlanForGroups->removeElement($stripePlanForGroup)) {
  512. // set the owning side to null (unless already changed)
  513. if ($stripePlanForGroup->getSubject() === $this) {
  514. $stripePlanForGroup->setSubject(null);
  515. }
  516. }
  518. return $this;
  519. }
  521. /**
  522. * @return Collection|UserPlacementTest[]
  523. */
  524. public function getUserPlacementTests(): Collection
  525. {
  526. return $this->userPlacementTests;
  527. }
  529. public function addUserPlacementTest(UserPlacementTest $userPlacementTest): self
  530. {
  531. if (!$this->userPlacementTests->contains($userPlacementTest)) {
  532. $this->userPlacementTests[] = $userPlacementTest;
  533. $userPlacementTest->setSubject($this);
  534. }
  536. return $this;
  537. }
  539. public function removeUserPlacementTest(UserPlacementTest $userPlacementTest): self
  540. {
  541. if ($this->userPlacementTests->removeElement($userPlacementTest)) {
  542. // set the owning side to null (unless already changed)
  543. if ($userPlacementTest->getSubject() === $this) {
  544. $userPlacementTest->setSubject(null);
  545. }
  546. }
  548. return $this;
  549. }
  551. /**
  552. * @return Collection|Exam[]
  553. */
  554. public function getExams(): Collection
  555. {
  556. return $this->exams;
  557. }
  559. public function addExam(Exam $exam): self
  560. {
  561. if (!$this->exams->contains($exam)) {
  562. $this->exams[] = $exam;
  563. $exam->setProgram($this);
  564. }
  566. return $this;
  567. }
  569. public function removeExam(Exam $exam): self
  570. {
  571. if ($this->exams->removeElement($exam)) {
  572. // set the owning side to null (unless already changed)
  573. if ($exam->getProgram() === $this) {
  574. $exam->setProgram(null);
  575. }
  576. }
  578. return $this;
  579. }
  581. /**
  582. * @return Collection|TrainingReport[]
  583. */
  584. public function getTrainingReports(): Collection
  585. {
  586. return $this->trainingReports;
  587. }
  589. public function addTrainingReport(TrainingReport $trainingReport): self
  590. {
  591. if (!$this->trainingReports->contains($trainingReport)) {
  592. $this->trainingReports[] = $trainingReport;
  593. $trainingReport->setProgram($this);
  594. }
  596. return $this;
  597. }
  599. public function removeTrainingReport(TrainingReport $trainingReport): self
  600. {
  601. if ($this->trainingReports->removeElement($trainingReport)) {
  602. // set the owning side to null (unless already changed)
  603. if ($trainingReport->getProgram() === $this) {
  604. $trainingReport->setProgram(null);
  605. }
  606. }
  608. return $this;
  609. }
  611. /**
  612. * @return Collection|Discount[]
  613. */
  614. public function getDiscounts(): Collection
  615. {
  616. return $this->discounts;
  617. }
  619. public function addDiscount(Discount $discount): self
  620. {
  621. if (!$this->discounts->contains($discount)) {
  622. $this->discounts[] = $discount;
  623. $discount->setSubject($this);
  624. }
  626. return $this;
  627. }
  629. public function removeDiscount(Discount $discount): self
  630. {
  631. if ($this->discounts->removeElement($discount)) {
  632. // set the owning side to null (unless already changed)
  633. if ($discount->getSubject() === $this) {
  634. $discount->setSubject(null);
  635. }
  636. }
  638. return $this;
  639. }
  641. public function getIsDefault(): ?bool
  642. {
  643. return $this->isDefault;
  644. }
  646. public function setIsDefault(?bool $isDefault): self
  647. {
  648. $this->isDefault = $isDefault;
  650. return $this;
  651. }
  653. public function getHasMidExam(): ?bool
  654. {
  655. return $this->hasMidExam;
  656. }
  658. public function setHasMidExam(?bool $hasMidExam): self
  659. {
  660. $this->hasMidExam = $hasMidExam;
  662. return $this;
  663. }
  665. public function getHasEndExam(): ?bool
  666. {
  667. return $this->hasEndExam;
  668. }
  670. public function setHasEndExam(?bool $hasEndExam): self
  671. {
  672. $this->hasEndExam = $hasEndExam;
  674. return $this;
  675. }
  677. public function getHasOralExam(): ?bool
  678. {
  679. return $this->hasOralExam;
  680. }
  682. public function setHasOralExam(?bool $hasOralExam): self
  683. {
  684. $this->hasOralExam = $hasOralExam;
  686. return $this;
  687. }
  689. /**
  690. * @return Collection<int, TeacherLeveltest>
  691. */
  692. public function getTeacherLeveltests(): Collection
  693. {
  694. return $this->teacherLeveltests;
  695. }
  697. public function addTeacherLeveltest(TeacherLeveltest $teacherLeveltest): self
  698. {
  699. if (!$this->teacherLeveltests->contains($teacherLeveltest)) {
  700. $this->teacherLeveltests[] = $teacherLeveltest;
  701. $teacherLeveltest->setSubject($this);
  702. }
  704. return $this;
  705. }
  707. public function removeTeacherLeveltest(TeacherLeveltest $teacherLeveltest): self
  708. {
  709. if ($this->teacherLeveltests->removeElement($teacherLeveltest)) {
  710. // set the owning side to null (unless already changed)
  711. if ($teacherLeveltest->getSubject() === $this) {
  712. $teacherLeveltest->setSubject(null);
  713. }
  714. }
  716. return $this;
  717. }
  719. /**
  720. * @return Collection<int, LevelTestAdvice>
  721. */
  722. public function getLevelTestAdvice(): Collection
  723. {
  724. return $this->levelTestAdvice;
  725. }
  727. public function addLevelTestAdvice(LevelTestAdvice $levelTestAdvice): self
  728. {
  729. if (!$this->levelTestAdvice->contains($levelTestAdvice)) {
  730. $this->levelTestAdvice[] = $levelTestAdvice;
  731. $levelTestAdvice->setSubject($this);
  732. }
  734. return $this;
  735. }
  737. public function removeLevelTestAdvice(LevelTestAdvice $levelTestAdvice): self
  738. {
  739. if ($this->levelTestAdvice->removeElement($levelTestAdvice)) {
  740. // set the owning side to null (unless already changed)
  741. if ($levelTestAdvice->getSubject() === $this) {
  742. $levelTestAdvice->setSubject(null);
  743. }
  744. }
  746. return $this;
  747. }
  750. }