src/Entity/Course.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CourseRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: CourseRepository::class)]
  12. class Course
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column(type: 'integer')]
  17.     private $id;
  19.     #[ORM\ManyToOne(targetEntity: ClubInfo::class, inversedBy: 'courses', fetch: "EAGER")]
  20.     private $club;
  22.     #[ORM\OneToOne(targetEntity: Address::class, inversedBy: 'course', cascade: ['persist', 'remove'])]
  23.     private $address;
  25.     #[ORM\OneToMany(targetEntity: Photo::class, mappedBy: 'course', cascade: ['persist', 'remove'])]
  26.     private $photos;
  28.     #[ORM\OneToMany(targetEntity: Video::class, mappedBy: 'course', cascade: ['persist', 'remove'])]
  29.     private $videos;
  31.     #[ORM\Column(type: 'array', nullable: true)]
  32.     private $logistic = [];
  34.     #[ORM\OneToMany(targetEntity: Airport::class, mappedBy: 'course', cascade: ['persist', 'remove'], orphanRemoval: true)]
  35.     private $airports;
  37.     #[ORM\OneToMany(targetEntity: Beach::class, mappedBy: 'course', cascade: ['persist', 'remove'], orphanRemoval: true)]
  38.     private $beaches;
  40.     #[ORM\OneToMany(targetEntity: Station::class, mappedBy: 'course', cascade: ['persist', 'remove'], orphanRemoval: true)]
  41.     private $stations;
  43.     #[ORM\OneToMany(targetEntity: Restaurant::class, mappedBy: 'course', cascade: ['persist', 'remove'], orphanRemoval: true)]
  44.     private $restaurants;
  46.     #[ORM\OneToMany(targetEntity: Accommodation::class, mappedBy: 'course', cascade: ['persist', 'remove'], orphanRemoval: true)]
  47.     private $accommodations;
  49.     #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'courses')]
  50.     private $owner;
  52.     #[ORM\ManyToMany(targetEntity: Sport::class, inversedBy: 'courses')]
  53.     private $sports;
  55.     #[ORM\OneToMany(targetEntity: CourseAvailability::class, mappedBy: 'course', cascade: ['persist', 'remove'])]
  56.     private $availabilities;
  58.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.     private $frequency;
  61.     #[ORM\ManyToMany(targetEntity: Language::class, inversedBy: 'courses')]
  62.     private $languages;
  63.     
  64.     #[ORM\OneToMany(targetEntity: FeaturedCourse::class, mappedBy: 'course')]
  65.     private $featureds;
  67.     #[ORM\Column(type: 'string', length: 255)]
  68.     private $status;
  70.     #[ORM\Column(type: 'datetime', nullable: true)]
  71.     private $createdAt;
  73.     #[ORM\ManyToMany(targetEntity: Age::class, inversedBy: 'courses')]
  74.     private $ages;
  76.     #[ORM\ManyToMany(targetEntity: Level::class, inversedBy: 'courses')]
  77.     private $levels;
  79.     #[ORM\ManyToMany(targetEntity: Trainee::class, mappedBy: 'favorites')]
  80.     private $traineesFavorites;
  82.     #[ORM\OneToMany(targetEntity: TranslatedCourse::class, mappedBy: 'course', cascade: ['persist', 'remove'])]
  83.     private $translatedContents;
  85.     #[ORM\Column(type: 'string', length: 255)]
  86.     private $token;
  88.     #[ORM\OneToMany(targetEntity: Booking::class, mappedBy: 'course')]
  89.     private $bookings;
  91.     #[ORM\Column(type: 'string', length: 255)]
  92.     private $countryCode;
  94.     #[ORM\Column(type: 'float', nullable: true)]
  95.     private $latitude;
  97.     #[ORM\Column(type: 'float', nullable: true)]
  98.     private $longitude;
  100.     #[ORM\OneToMany(targetEntity: CourseViewsStat::class, mappedBy: 'course', cascade: ['persist', 'remove'])]
  101.     private $courseViewsStats;
  103.     #[ORM\Column(type: 'boolean')]
  104.     private $hideClubInfo;
  106.     #[ORM\Column(type: 'boolean')]
  107.     private $hideCoachInfo;
  109.     #[ORM\Column(type: 'integer', length: 255, nullable: true)]
  110.     private $stepSaved;
  112.     #[ORM\ManyToMany(targetEntity: CoachInfo::class, inversedBy: 'courses')]
  113.     private $coachsInfos;
  115.     #[ORM\Column(type: 'boolean', nullable: true)]
  116.     private $sendedAlert;
  118.     #[ORM\Column(length: 255, nullable: true)]
  119.     private ?string $cover = null;
  121.     #[ORM\OneToMany(mappedBy: 'course', targetEntity: PriceBundle::class)]
  122.     private Collection $priceBundles;
  124.     private $translateName;
  125.     private $translateDescription;
  126.     private $translatePlanning;
  127.     private $translateOther;
  129.     #[ORM\Column(nullable: true)]
  130.     private ?bool $visibleToClub = true;
  132.     #[ORM\Column(nullable: true)]
  133.     private ?bool $visibleToCoach = true;
  135.     #[ORM\Column(nullable: true)]
  136.     private ?bool $visibleToOperator = true;
  138.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  139.     private ?\DateTimeInterface $publishedAt = null;
  141.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  142.     private ?\DateTimeInterface $updatedAt = null;
  144.     #[ORM\ManyToOne(inversedBy: 'associatedCourses')]
  145.     private ?OperatorInfo $operator = null;
  147.     #[ORM\OneToMany(mappedBy: 'course', targetEntity: NoteRequest::class)]
  148.     private Collection $noteRequests;
  150.     #[ORM\OneToMany(mappedBy: 'course', targetEntity: Note::class)]
  151.     private Collection $notes;
  153.     public function __construct()
  154.     {
  155.         $this->photos = new ArrayCollection();
  156.         $this->videos = new ArrayCollection();
  157.         $this->airports = new ArrayCollection();
  158.         $this->beaches = new ArrayCollection();
  159.         $this->stations = new ArrayCollection();
  160.         $this->restaurants = new ArrayCollection();
  161.         $this->accommodations = new ArrayCollection();
  162.         $this->sports = new ArrayCollection();
  163.         $this->availabilities = new ArrayCollection();
  164.         $this->languages = new ArrayCollection();
  165.         $this->featureds = new ArrayCollection();
  166.         $this->ages = new ArrayCollection();
  167.         $this->levels = new ArrayCollection();
  168.         $this->traineesFavorites = new ArrayCollection();
  169.         $this->translatedContents = new ArrayCollection();
  170.         $this->bookings = new ArrayCollection();
  171.         $this->courseViewsStats = new ArrayCollection();
  172.         $this->coachsInfos = new ArrayCollection();
  173.         $this->priceBundles = new ArrayCollection();
  174.         $this->noteRequests = new ArrayCollection();
  175.         $this->notes = new ArrayCollection();
  176.     }
  178.     public function getId(): ?int
  179.     {
  180.         return $this->id;
  181.     }
  183.     public function  getPrice()
  184.     {
  185.         return $this->availabilities->first()->getPrice();
  186.     }
  187.     
  189.     public function getClub(): ?ClubInfo
  190.     {
  191.         return $this->club;
  192.     }
  194.     public function setClub(?ClubInfo $club): self
  195.     {
  196.         $this->club = $club;
  198.         return $this;
  199.     }
  201.     public function getAddress(): ?Address
  202.     {
  203.         return $this->address;
  204.     }
  206.     public function setAddress(?Address $address): self
  207.     {
  208.         $this->address = $address;
  210.         return $this;
  211.     }
  213.     /**
  214.      * @return Collection|Photo[]
  215.      */
  216.     public function getPhotos(): Collection
  217.     {
  218.         return $this->photos;
  219.     }
  221.     public function addPhoto(Photo $photo): self
  222.     {
  223.         if (!$this->photos->contains($photo)) {
  224.             $this->photos[] = $photo;
  225.             $photo->setCourse($this);
  226.         }
  228.         return $this;
  229.     }
  231.     public function removePhoto(Photo $photo): self
  232.     {
  233.         if ($this->photos->removeElement($photo)) {
  234.             // set the owning side to null (unless already changed)
  235.             if ($photo->getCourse() === $this) {
  236.                 $photo->setCourse(null);
  237.             }
  238.         }
  240.         return $this;
  241.     }
  243.     /**
  244.      * @return Collection|Video[]
  245.      */
  246.     public function getVideos(): Collection
  247.     {
  248.         return $this->videos;
  249.     }
  251.     public function addVideo(Video $video): self
  252.     {
  253.         if (!$this->videos->contains($video)) {
  254.             $this->videos[] = $video;
  255.             $video->setCourse($this);
  256.         }
  258.         return $this;
  259.     }
  261.     public function removeVideo(Video $video): self
  262.     {
  263.         if ($this->videos->removeElement($video)) {
  264.             // set the owning side to null (unless already changed)
  265.             if ($video->getCourse() === $this) {
  266.                 $video->setCourse(null);
  267.             }
  268.         }
  270.         return $this;
  271.     }
  273.     public function getLogistic(): ?array
  274.     {
  275.         return $this->logistic;
  276.     }
  278.     public function setLogistic(?array $logistic): self
  279.     {
  280.         $this->logistic = $logistic;
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection|Airport[]
  287.      */
  288.     public function getAirports(): Collection
  289.     {
  290.         return $this->airports;
  291.     }
  293.     public function addAirport(Airport $airport): self
  294.     {
  295.         if (!$this->airports->contains($airport)) {
  296.             $this->airports[] = $airport;
  297.             $airport->setCourse($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeAirport(Airport $airport): self
  304.     {
  305.         if ($this->airports->removeElement($airport)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($airport->getCourse() === $this) {
  308.                 $airport->setCourse(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     /**
  316.      * @return Collection|Beach[]
  317.      */
  318.     public function getBeaches(): Collection
  319.     {
  320.         return $this->beaches;
  321.     }
  323.     public function addBeach(Beach $beach): self
  324.     {
  325.         if (!$this->beaches->contains($beach)) {
  326.             $this->beaches[] = $beach;
  327.             $beach->setCourse($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeBeach(Beach $beach): self
  334.     {
  335.         if ($this->beaches->removeElement($beach)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($beach->getCourse() === $this) {
  338.                 $beach->setCourse(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     /**
  346.      * @return Collection|Station[]
  347.      */
  348.     public function getStations(): Collection
  349.     {
  350.         return $this->stations;
  351.     }
  353.     public function addStation(Station $station): self
  354.     {
  355.         if (!$this->stations->contains($station)) {
  356.             $this->stations[] = $station;
  357.             $station->setCourse($this);
  358.         }
  360.         return $this;
  361.     }
  363.     public function removeStation(Station $station): self
  364.     {
  365.         if ($this->stations->removeElement($station)) {
  366.             // set the owning side to null (unless already changed)
  367.             if ($station->getCourse() === $this) {
  368.                 $station->setCourse(null);
  369.             }
  370.         }
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection|Restaurant[]
  377.      */
  378.     public function getRestaurants(): Collection
  379.     {
  380.         return $this->restaurants;
  381.     }
  383.     public function addRestaurant(Restaurant $restaurant): self
  384.     {
  385.         if (!$this->restaurants->contains($restaurant)) {
  386.             $this->restaurants[] = $restaurant;
  387.             $restaurant->setCourse($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeRestaurant(Restaurant $restaurant): self
  394.     {
  395.         if ($this->restaurants->removeElement($restaurant)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($restaurant->getCourse() === $this) {
  398.                 $restaurant->setCourse(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.     /**
  406.      * @return Collection|Accommodation[]
  407.      */
  408.     public function getAccommodations(): Collection
  409.     {
  410.         return $this->accommodations;
  411.     }
  413.     public function addAccommodation(Accommodation $accommodation): self
  414.     {
  415.         if (!$this->accommodations->contains($accommodation)) {
  416.             $this->accommodations[] = $accommodation;
  417.             $accommodation->setCourse($this);
  418.         }
  420.         return $this;
  421.     }
  423.     public function removeAccommodation(Accommodation $accommodation): self
  424.     {
  425.         if ($this->accommodations->removeElement($accommodation)) {
  426.             // set the owning side to null (unless already changed)
  427.             if ($accommodation->getCourse() === $this) {
  428.                 $accommodation->setCourse(null);
  429.             }
  430.         }
  432.         return $this;
  433.     }
  435.     public function getOwner(): ?User
  436.     {
  437.         return $this->owner;
  438.     }
  440.     public function setOwner(?User $owner): self
  441.     {
  442.         $this->owner = $owner;
  444.         return $this;
  445.     }
  447.     /**
  448.      * @return Collection|Sport[]
  449.      */
  450.     public function getSports(): Collection
  451.     {
  452.         return $this->sports;
  453.     }
  455.     public function addSport(Sport $sport): self
  456.     {
  457.         if (!$this->sports->contains($sport)) {
  458.             $this->sports[] = $sport;
  459.         }
  461.         return $this;
  462.     }
  464.     public function removeSport(Sport $sport): self
  465.     {
  466.         $this->sports->removeElement($sport);
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection|CourseAvailability[]
  473.      */
  474.     public function getAvailabilities(): Collection
  475.     {
  476.         return $this->availabilities;
  477.     }
  479.     public function addAvailability(CourseAvailability $availability): self
  480.     {
  481.         if (!$this->availabilities->contains($availability)) {
  482.             $this->availabilities[] = $availability;
  483.             $availability->setCourse($this);
  484.         }
  486.         return $this;
  487.     }
  489.     public function removeAvailability(CourseAvailability $availability): self
  490.     {
  491.         if ($this->availabilities->removeElement($availability)) {
  492.             // set the owning side to null (unless already changed)
  493.             if ($availability->getCourse() === $this) {
  494.                 $availability->setCourse(null);
  495.             }
  496.         }
  498.         return $this;
  499.     }
  501.     public function getFrequency(): ?string
  502.     {
  503.         return $this->frequency;
  504.     }
  506.     public function setFrequency(string $frequency): self
  507.     {
  508.         $this->frequency = $frequency;
  510.         return $this;
  511.     }
  513.     /**
  514.      * @return Collection|Language[]
  515.      */
  516.     public function getLanguages(): Collection
  517.     {
  518.         return $this->languages;
  519.     }
  521.     public function addLanguage(Language $language): self
  522.     {
  523.         if (!$this->languages->contains($language)) {
  524.             $this->languages[] = $language;
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeLanguage(Language $language): self
  531.     {
  532.         $this->languages->removeElement($language);
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection|FeaturedCourse[]
  539.      */
  540.     public function getFeatureds(): Collection
  541.     {
  542.         return $this->featureds;
  543.     }
  545.     public function addFeatured(FeaturedCourse $featured): self
  546.     {
  547.         if (!$this->featureds->contains($featured)) {
  548.             $this->featureds[] = $featured;
  549.             $featured->setCourse($this);
  550.         }
  551.         return $this;
  552.     }
  554.     public function removeFeatured(FeaturedCourse $featured): self
  555.     {
  556.         if ($this->featureds->removeElement($featured)) {
  557.             // set the owning side to null (unless already changed)
  558.             if ($featured->getCourse() === $this) {
  559.                 $featured->setCourse(null);
  560.             }
  561.         }
  563.         return $this;
  564.     }
  566.     public function getStatus(): ?string
  567.     {
  568.         return $this->status;
  569.     }
  571.     public function setStatus(string $status): self
  572.     {
  573.         $this->status = $status;
  575.         return $this;
  576.     }
  578.     public function getCreatedAt(): ?\DateTimeInterface
  579.     {
  580.         return $this->createdAt;
  581.     }
  583.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  584.     {
  585.         $this->createdAt = $createdAt;
  587.         return $this;
  588.     }
  590.     /**
  591.      * @return Collection|Age[]
  592.      */
  593.     public function getAges(): Collection
  594.     {
  595.         return $this->ages;
  596.     }
  598.     public function addAge(Age $age): self
  599.     {
  600.         if (!$this->ages->contains($age)) {
  601.             $this->ages[] = $age;
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeAge(Age $age): self
  608.     {
  609.         $this->ages->removeElement($age);
  611.         return $this;
  612.     }
  614.     /**
  615.      * @return Collection|Level[]
  616.      */
  617.     public function getLevels(): Collection
  618.     {
  619.         return $this->levels;
  620.     }
  622.     public function addLevel(Level $level): self
  623.     {
  624.         if (!$this->levels->contains($level)) {
  625.             $this->levels[] = $level;
  626.         }
  628.         return $this;
  629.     }
  631.     public function removeLevel(Level $level): self
  632.     {
  633.         $this->levels->removeElement($level);
  635.         return $this;
  636.     }
  638.     /**
  639.      * @return Collection|Trainee[]
  640.      */
  641.     public function getTraineesFavorites(): Collection
  642.     {
  643.         return $this->traineesFavorites;
  644.     }
  646.     public function addTraineesFavorite(Trainee $traineesFavorite): self
  647.     {
  648.         if (!$this->traineesFavorites->contains($traineesFavorite)) {
  649.             $this->traineesFavorites[] = $traineesFavorite;
  650.             $traineesFavorite->addFavorite($this);
  651.         }
  653.         return $this;
  654.     }
  656.     public function removeTraineesFavorite(Trainee $traineesFavorite): self
  657.     {
  658.         if ($this->traineesFavorites->removeElement($traineesFavorite)) {
  659.             $traineesFavorite->removeFavorite($this);
  660.         }
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection|TranslatedCourse[]
  667.      */
  668.     public function getTranslatedContents(): Collection
  669.     {
  670.         return $this->translatedContents;
  671.     }
  673.     public function addTranslatedContent(TranslatedCourse $translatedContent): self
  674.     {
  675.         if (!$this->translatedContents->contains($translatedContent)) {
  676.             $this->translatedContents[] = $translatedContent;
  677.             $translatedContent->setCourse($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeTranslatedContent(TranslatedCourse $translatedContent): self
  684.     {
  685.         if ($this->translatedContents->removeElement($translatedContent)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($translatedContent->getCourse() === $this) {
  688.                 $translatedContent->setCourse(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     public function getToken(): ?string
  696.     {
  697.         return $this->token;
  698.     }
  700.     public function setToken(string $token): self
  701.     {
  702.         $this->token = $token;
  704.         return $this;
  705.     }
  706.     
  707.     public function getTranslatedContent($local)
  708.     {
  709.         foreach($this->translatedContents as $translatedCourse)
  710.         {
  711.             if($translatedCourse->getLanguage() == $local)
  712.             {
  713.                 return $translatedCourse;
  714.             }
  715.         }
  716.         foreach($this->translatedContents as $translatedCourse)
  717.         {
  718.             if($translatedCourse->getLanguage() == 'en')
  719.             {
  720.                 return $translatedCourse;
  721.             }
  722.         }
  723.         return $this->getTranslatedContents()->first() ?? null;
  724.     }
  726.     /**
  727.      * @return Collection|Booking[]
  728.      */
  729.     public function getBookings(): Collection
  730.     {
  731.         return $this->bookings;
  732.     }
  734.     public function addBooking(Booking $booking): self
  735.     {
  736.         if (!$this->bookings->contains($booking)) {
  737.             $this->bookings[] = $booking;
  738.             $booking->setCourse($this);
  739.         }
  741.         return $this;
  742.     }
  744.     public function removeBooking(Booking $booking): self
  745.     {
  746.         if ($this->bookings->removeElement($booking)) {
  747.             // set the owning side to null (unless already changed)
  748.             if ($booking->getCourse() === $this) {
  749.                 $booking->setCourse(null);
  750.             }
  751.         }
  753.         return $this;
  754.     }
  756.     public function getCountryCode(): ?string
  757.     {
  758.         return $this->countryCode;
  759.     }
  761.     public function setCountryCode(string $countryCode): self
  762.     {
  763.         $this->countryCode = $countryCode;
  765.         return $this;
  766.     }
  768.     public function getLatitude(): ?float
  769.     {
  770.         return $this->latitude;
  771.     }
  773.     public function setLatitude(?float $latitude): self
  774.     {
  775.         $this->latitude = $latitude;
  777.         return $this;
  778.     }
  780.     public function getLongitude(): ?float
  781.     {
  782.         return $this->longitude;
  783.     }
  785.     public function setLongitude(?float $longitude): self
  786.     {
  787.         $this->longitude = $longitude;
  789.         return $this;
  790.     }
  792.     /**
  793.      * @return Collection|CourseViewsStat[]
  794.      */
  795.     public function getCourseViewsStats(): Collection
  796.     {
  797.         return $this->courseViewsStats;
  798.     }
  800.     public function addCourseViewsStat(CourseViewsStat $courseViewsStat): self
  801.     {
  802.         if (!$this->courseViewsStats->contains($courseViewsStat)) {
  803.             $this->courseViewsStats[] = $courseViewsStat;
  804.             $courseViewsStat->setCourse($this);
  805.         }
  807.         return $this;
  808.     }
  810.     public function removeCourseViewsStat(CourseViewsStat $courseViewsStat): self
  811.     {
  812.         if ($this->courseViewsStats->removeElement($courseViewsStat)) {
  813.             // set the owning side to null (unless already changed)
  814.             if ($courseViewsStat->getCourse() === $this) {
  815.                 $courseViewsStat->setCourse(null);
  816.             }
  817.         }
  819.         return $this;
  820.     }
  822.     public function getHideClubInfo(): ?bool
  823.     {
  824.         return $this->hideClubInfo;
  825.     }
  827.     public function setHideClubInfo(bool $hideClubInfo): self
  828.     {
  829.         $this->hideClubInfo = $hideClubInfo;
  831.         return $this;
  832.     }
  834.     public function getHideCoachInfo(): ?bool
  835.     {
  836.         return $this->hideCoachInfo;
  837.     }
  839.     public function setHideCoachInfo(bool $hideCoachInfo): self
  840.     {
  841.         $this->hideCoachInfo = $hideCoachInfo;
  843.         return $this;
  844.     }
  846.     public function getStepSaved(): ?int
  847.     {
  848.         return $this->stepSaved;
  849.     }
  851.     public function setStepSaved(?int $stepSaved): self
  852.     {
  853.         $this->stepSaved = $stepSaved;
  855.         return $this;
  856.     }
  858.     /**
  859.      * @return Collection<int, CoachInfo>
  860.      */
  861.     public function getCoachsInfos(): Collection
  862.     {
  863.         return $this->coachsInfos;
  864.     }
  866.     public function addCoachsInfo(CoachInfo $coachsInfo): self
  867.     {
  868.         if (!$this->coachsInfos->contains($coachsInfo)) {
  869.             $this->coachsInfos[] = $coachsInfo;
  870.         }
  872.         return $this;
  873.     }
  875.     public function removeCoachsInfo(CoachInfo $coachsInfo): self
  876.     {
  877.         $this->coachsInfos->removeElement($coachsInfo);
  879.         return $this;
  880.     }
  882.     public function getSendedAlert(): ?bool
  883.     {
  884.         return $this->sendedAlert;
  885.     }
  887.     public function setSendedAlert(?bool $sendedAlert): self
  888.     {
  889.         $this->sendedAlert = $sendedAlert;
  891.         return $this;
  892.     }
  894.     public function getCover()
  895.     {
  896.         return $this->cover;
  897.     }
  899.     public function setCover($cover): static
  900.     {
  901.         $this->cover = $cover;
  903.         return $this;
  904.     }
  906.     /**
  907.      * @return Collection<int, PriceBundle>
  908.      */
  909.     public function getPriceBundles(): Collection
  910.     {
  911.         return $this->priceBundles;
  912.     }
  914.     public function addPriceBundle(PriceBundle $priceBundle): static
  915.     {
  916.         if (!$this->priceBundles->contains($priceBundle)) {
  917.             $this->priceBundles->add($priceBundle);
  918.             $priceBundle->setCourse($this);
  919.         }
  921.         return $this;
  922.     }
  924.     public function removePriceBundle(PriceBundle $priceBundle): static
  925.     {
  926.         if ($this->priceBundles->removeElement($priceBundle)) {
  927.             // set the owning side to null (unless already changed)
  928.             if ($priceBundle->getCourse() === $this) {
  929.                 $priceBundle->setCourse(null);
  930.             }
  931.         }
  933.         return $this;
  934.     }
  937.     /**
  938.      * Get the value of translateName
  939.      */ 
  940.     public function getTranslateName()
  941.     {
  942.         return $this->translateName;
  943.     }
  945.     /**
  946.      * Set the value of translateName
  947.      *
  948.      * @return  self
  949.      */ 
  950.     public function setTranslateName($translateName)
  951.     {
  952.         $this->translateName = $translateName;
  954.         return $this;
  955.     }
  957.     /**
  958.      * Get the value of translateDescription
  959.      */ 
  960.     public function getTranslateDescription()
  961.     {
  962.         return $this->translateDescription;
  963.     }
  965.     /**
  966.      * Set the value of translateDescription
  967.      *
  968.      * @return  self
  969.      */ 
  970.     public function setTranslateDescription($translateDescription)
  971.     {
  972.         $this->translateDescription = $translateDescription;
  974.         return $this;
  975.     }
  977.     /**
  978.      * Get the value of translatePlanning
  979.      */ 
  980.     public function getTranslatePlanning()
  981.     {
  982.         return $this->translatePlanning;
  983.     }
  985.     /**
  986.      * Set the value of translatePlanning
  987.      *
  988.      * @return  self
  989.      */ 
  990.     public function setTranslatePlanning($translatePlanning)
  991.     {
  992.         $this->translatePlanning = $translatePlanning;
  994.         return $this;
  995.     }
  997.     /**
  998.      * Get the value of translateOther
  999.      */ 
  1000.     public function getTranslateOther()
  1001.     {
  1002.         return $this->translateOther;
  1003.     }
  1005.     /**
  1006.      * Set the value of translateOther
  1007.      *
  1008.      * @return  self
  1009.      */ 
  1010.     public function setTranslateOther($translateOther)
  1011.     {
  1012.         $this->translateOther = $translateOther;
  1014.         return $this;
  1015.     }
  1017.     public function isVisibleToClub(): ?bool
  1018.     {
  1019.         return $this->visibleToClub;
  1020.     }
  1022.     public function setVisibleToClub(?bool $visibleToClub): static
  1023.     {
  1024.         $this->visibleToClub = $visibleToClub;
  1026.         return $this;
  1027.     }
  1029.     public function isVisibleToCoach(): ?bool
  1030.     {
  1031.         return $this->visibleToCoach;
  1032.     }
  1034.     public function setVisibleToCoach(?bool $visibleToCoach): static
  1035.     {
  1036.         $this->visibleToCoach = $visibleToCoach;
  1038.         return $this;
  1039.     }
  1041.     public function isVisibleToOperator(): ?bool
  1042.     {
  1043.         return $this->visibleToOperator;
  1044.     }
  1046.     public function setVisibleToOperator(?bool $visibleToOperator): static
  1047.     {
  1048.         $this->visibleToOperator = $visibleToOperator;
  1050.         return $this;
  1051.     }
  1053.     public function getPublishedAt(): ?\DateTimeInterface
  1054.     {
  1055.         return $this->publishedAt;
  1056.     }
  1058.     public function setPublishedAt(?\DateTimeInterface $publishedAt): static
  1059.     {
  1060.         $this->publishedAt = $publishedAt;
  1062.         return $this;
  1063.     }
  1065.     public function getUpdatedAt(): ?\DateTimeInterface
  1066.     {
  1067.         return $this->updatedAt;
  1068.     }
  1070.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): static
  1071.     {
  1072.         $this->updatedAt = $updatedAt;
  1074.         return $this;
  1075.     }
  1077.     public function getOperator(): ?OperatorInfo
  1078.     {
  1079.         return $this->operator;
  1080.     }
  1082.     public function setOperator(?OperatorInfo $operator): static
  1083.     {
  1084.         $this->operator = $operator;
  1086.         return $this;
  1087.     }
  1089.     /**
  1090.      * @return Collection<int, NoteRequest>
  1091.      */
  1092.     public function getNoteRequests(): Collection
  1093.     {
  1094.         return $this->noteRequests;
  1095.     }
  1097.     public function addNoteRequest(NoteRequest $noteRequest): static
  1098.     {
  1099.         if (!$this->noteRequests->contains($noteRequest)) {
  1100.             $this->noteRequests->add($noteRequest);
  1101.             $noteRequest->setCourse($this);
  1102.         }
  1104.         return $this;
  1105.     }
  1107.     public function removeNoteRequest(NoteRequest $noteRequest): static
  1108.     {
  1109.         if ($this->noteRequests->removeElement($noteRequest)) {
  1110.             // set the owning side to null (unless already changed)
  1111.             if ($noteRequest->getCourse() === $this) {
  1112.                 $noteRequest->setCourse(null);
  1113.             }
  1114.         }
  1116.         return $this;
  1117.     }
  1119.     /**
  1120.      * @return Collection<int, Note>
  1121.      */
  1122.     public function getNotes(): Collection
  1123.     {
  1124.         return $this->notes;
  1125.     }
  1127.     public function addNote(Note $note): static
  1128.     {
  1129.         if (!$this->notes->contains($note)) {
  1130.             $this->notes->add($note);
  1131.             $note->setCourse($this);
  1132.         }
  1134.         return $this;
  1135.     }
  1137.     public function removeNote(Note $note): static
  1138.     {
  1139.         if ($this->notes->removeElement($note)) {
  1140.             // set the owning side to null (unless already changed)
  1141.             if ($note->getCourse() === $this) {
  1142.                 $note->setCourse(null);
  1143.             }
  1144.         }
  1146.         return $this;
  1147.     }
  1148. }