src/Entity/Sport.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SportRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: SportRepository::class)]
  11. class Sport
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column(type: 'integer')]
  16.     private $id;
  18.     #[ORM\Column(type: 'string', length: 255)]
  19.     private $name;
  21.     #[ORM\Column(type: 'string', length: 255)]
  22.     private $slug;
  24.     #[ORM\Column(type: 'string', length: 255)]
  25.     private $icon;
  27.     #[ORM\OneToMany(targetEntity: CourtInfo::class, mappedBy: 'sport')]
  28.     private $courtInfos;
  30.     #[ORM\ManyToMany(targetEntity: ProInfo::class, mappedBy: 'sports')]
  31.     private $pros;
  33.     
  34.     #[ORM\OneToMany(targetEntity: SportTrainee::class, mappedBy: 'sport')]
  35.     private $trainees;
  37.     #[ORM\ManyToMany(targetEntity: Course::class, mappedBy: 'sports')]
  38.     private $courses;
  40.     #[ORM\OneToMany(targetEntity: Availability::class, mappedBy: 'sport')]
  41.     private $availabilities;
  43.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.     private $status;
  46.     #[ORM\Column(type: 'integer', nullable: true)]
  47.     private $appearance;
  50.     public function __construct()
  51.     {
  52.         $this->courtInfos = new ArrayCollection();
  53.         $this->pros = new ArrayCollection();
  54.         $this->trainees = new ArrayCollection();
  55.         $this->courses = new ArrayCollection();
  56.         $this->availabilities = new ArrayCollection();
  57.     }
  59.     public function __toString()
  60.     {
  61.         return $this->name;
  62.     }
  64.     public function getId(): ?int
  65.     {
  66.         return $this->id;
  67.     }
  69.     public function getName(): ?string
  70.     {
  71.         return $this->name;
  72.     }
  74.     public function setName(string $name): self
  75.     {
  76.         $this->name = $name;
  78.         return $this;
  79.     }
  81.     public function getSlug(): ?string
  82.     {
  83.         return $this->slug;
  84.     }
  86.     public function setSlug(string $slug): self
  87.     {
  88.         $this->slug = $slug;
  90.         return $this;
  91.     }
  93.     public function getIcon()
  94.     {
  95.         return $this->icon;
  96.     }
  98.     public function setIcon($icon): self
  99.     {
  100.         $this->icon = $icon;
  102.         return $this;
  103.     }
  105.     /**
  106.      * @return Collection|CourtInfo[]
  107.      */
  108.     public function getCourtInfos(): Collection
  109.     {
  110.         return $this->courtInfos;
  111.     }
  113.     public function addCourtInfo(CourtInfo $courtInfo): self
  114.     {
  115.         if (!$this->courtInfos->contains($courtInfo)) {
  116.             $this->courtInfos[] = $courtInfo;
  117.             $courtInfo->setSport($this);
  118.         }
  120.         return $this;
  121.     }
  123.     public function removeCourtInfo(CourtInfo $courtInfo): self
  124.     {
  125.         if ($this->courtInfos->removeElement($courtInfo)) {
  126.             // set the owning side to null (unless already changed)
  127.             if ($courtInfo->getSport() === $this) {
  128.                 $courtInfo->setSport(null);
  129.             }
  130.         }
  132.         return $this;
  133.     }
  135.     /**
  136.      * @return Collection|ProInfo[]
  137.      */
  138.     public function getPros(): Collection
  139.     {
  140.         return $this->pros;
  141.     }
  143.     public function addPro(ProInfo $pro): self
  144.     {
  145.         if (!$this->pros->contains($pro)) {
  146.             $this->pros[] = $pro;
  147.             $pro->addSport($this);
  148.         }
  150.         return $this;
  151.     }
  153.     public function removePro(ProInfo $pro): self
  154.     {
  155.         if ($this->pros->removeElement($pro)) {
  156.             $pro->removeSport($this);
  157.         }
  159.         return $this;
  160.     }
  162.     /**
  163.      * @return Collection|SportTrainee[]
  164.      */
  165.     public function getTrainees(): Collection
  166.     {
  167.         return $this->trainees;
  168.     }
  170.     public function addTrainee(SportTrainee $trainee): self
  171.     {
  172.         if (!$this->trainees->contains($trainee)) {
  173.             $this->trainees[] = $trainee;
  174.             $trainee->setSport($this);
  175.         }
  177.         return $this;
  178.     }
  180.     public function removeTrainee(SportTrainee $trainee): self
  181.     {
  182.         if ($this->trainees->removeElement($trainee)) {
  183.             // set the owning side to null (unless already changed)
  184.             if ($trainee->getSport() === $this) {
  185.                 $trainee->setSport(null);
  186.             }
  187.         }
  189.         return $this;
  190.     }
  192.     /**
  193.      * @return Collection|Course[]
  194.      */
  195.     public function getCourses(): Collection
  196.     {
  197.         return $this->courses;
  198.     }
  200.     public function addCourse(Course $course): self
  201.     {
  202.         if (!$this->courses->contains($course)) {
  203.             $this->courses[] = $course;
  204.             $course->addSport($this);
  205.         }
  207.         return $this;
  208.     }
  210.     public function removeCourse(Course $course): self
  211.     {
  212.         if ($this->courses->removeElement($course)) {
  213.             $course->removeSport($this);
  214.         }
  216.         return $this;
  217.     }
  219.     /**
  220.      * @return Collection|Availability[]
  221.      */
  222.     public function getAvailabilities(): Collection
  223.     {
  224.         return $this->availabilities;
  225.     }
  227.     public function addAvailability(Availability $availability): self
  228.     {
  229.         if (!$this->availabilities->contains($availability)) {
  230.             $this->availabilities[] = $availability;
  231.             $availability->setSport($this);
  232.         }
  234.         return $this;
  235.     }
  237.     public function removeAvailability(Availability $availability): self
  238.     {
  239.         if ($this->availabilities->removeElement($availability)) {
  240.             // set the owning side to null (unless already changed)
  241.             if ($availability->getSport() === $this) {
  242.                 $availability->setSport(null);
  243.             }
  244.         }
  246.         return $this;
  247.     }
  249.     public function getStatus(): ?string
  250.     {
  251.         return $this->status;
  252.     }
  254.     public function setStatus(?string $status): self
  255.     {
  256.         $this->status = $status;
  258.         return $this;
  259.     }
  261.     public function getAppearance(): ?int
  262.     {
  263.         return $this->appearance;
  264.     }
  266.     public function setAppearance(?int $appearance): self
  267.     {
  268.         $this->appearance = $appearance;
  270.         return $this;
  271.     }
  272. }