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.     }
  184.     public function getClub(): ?ClubInfo
  185.     {
  186.         return $this->club;
  187.     }
  189.     public function setClub(?ClubInfo $club): self
  190.     {
  191.         $this->club = $club;
  193.         return $this;
  194.     }
  196.     public function getAddress(): ?Address
  197.     {
  198.         return $this->address;
  199.     }
  201.     public function setAddress(?Address $address): self
  202.     {
  203.         $this->address = $address;
  205.         return $this;
  206.     }
  208.     /**
  209.      * @return Collection|Photo[]
  210.      */
  211.     public function getPhotos(): Collection
  212.     {
  213.         return $this->photos;
  214.     }
  216.     public function addPhoto(Photo $photo): self
  217.     {
  218.         if (!$this->photos->contains($photo)) {
  219.             $this->photos[] = $photo;
  220.             $photo->setCourse($this);
  221.         }
  223.         return $this;
  224.     }
  226.     public function removePhoto(Photo $photo): self
  227.     {
  228.         if ($this->photos->removeElement($photo)) {
  229.             // set the owning side to null (unless already changed)
  230.             if ($photo->getCourse() === $this) {
  231.                 $photo->setCourse(null);
  232.             }
  233.         }
  235.         return $this;
  236.     }
  238.     /**
  239.      * @return Collection|Video[]
  240.      */
  241.     public function getVideos(): Collection
  242.     {
  243.         return $this->videos;
  244.     }
  246.     public function addVideo(Video $video): self
  247.     {
  248.         if (!$this->videos->contains($video)) {
  249.             $this->videos[] = $video;
  250.             $video->setCourse($this);
  251.         }
  253.         return $this;
  254.     }
  256.     public function removeVideo(Video $video): self
  257.     {
  258.         if ($this->videos->removeElement($video)) {
  259.             // set the owning side to null (unless already changed)
  260.             if ($video->getCourse() === $this) {
  261.                 $video->setCourse(null);
  262.             }
  263.         }
  265.         return $this;
  266.     }
  268.     public function getLogistic(): ?array
  269.     {
  270.         return $this->logistic;
  271.     }
  273.     public function setLogistic(?array $logistic): self
  274.     {
  275.         $this->logistic = $logistic;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return Collection|Airport[]
  282.      */
  283.     public function getAirports(): Collection
  284.     {
  285.         return $this->airports;
  286.     }
  288.     public function addAirport(Airport $airport): self
  289.     {
  290.         if (!$this->airports->contains($airport)) {
  291.             $this->airports[] = $airport;
  292.             $airport->setCourse($this);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeAirport(Airport $airport): self
  299.     {
  300.         if ($this->airports->removeElement($airport)) {
  301.             // set the owning side to null (unless already changed)
  302.             if ($airport->getCourse() === $this) {
  303.                 $airport->setCourse(null);
  304.             }
  305.         }
  307.         return $this;
  308.     }
  310.     /**
  311.      * @return Collection|Beach[]
  312.      */
  313.     public function getBeaches(): Collection
  314.     {
  315.         return $this->beaches;
  316.     }
  318.     public function addBeach(Beach $beach): self
  319.     {
  320.         if (!$this->beaches->contains($beach)) {
  321.             $this->beaches[] = $beach;
  322.             $beach->setCourse($this);
  323.         }
  325.         return $this;
  326.     }
  328.     public function removeBeach(Beach $beach): self
  329.     {
  330.         if ($this->beaches->removeElement($beach)) {
  331.             // set the owning side to null (unless already changed)
  332.             if ($beach->getCourse() === $this) {
  333.                 $beach->setCourse(null);
  334.             }
  335.         }
  337.         return $this;
  338.     }
  340.     /**
  341.      * @return Collection|Station[]
  342.      */
  343.     public function getStations(): Collection
  344.     {
  345.         return $this->stations;
  346.     }
  348.     public function addStation(Station $station): self
  349.     {
  350.         if (!$this->stations->contains($station)) {
  351.             $this->stations[] = $station;
  352.             $station->setCourse($this);
  353.         }
  355.         return $this;
  356.     }
  358.     public function removeStation(Station $station): self
  359.     {
  360.         if ($this->stations->removeElement($station)) {
  361.             // set the owning side to null (unless already changed)
  362.             if ($station->getCourse() === $this) {
  363.                 $station->setCourse(null);
  364.             }
  365.         }
  367.         return $this;
  368.     }
  370.     /**
  371.      * @return Collection|Restaurant[]
  372.      */
  373.     public function getRestaurants(): Collection
  374.     {
  375.         return $this->restaurants;
  376.     }
  378.     public function addRestaurant(Restaurant $restaurant): self
  379.     {
  380.         if (!$this->restaurants->contains($restaurant)) {
  381.             $this->restaurants[] = $restaurant;
  382.             $restaurant->setCourse($this);
  383.         }
  385.         return $this;
  386.     }
  388.     public function removeRestaurant(Restaurant $restaurant): self
  389.     {
  390.         if ($this->restaurants->removeElement($restaurant)) {
  391.             // set the owning side to null (unless already changed)
  392.             if ($restaurant->getCourse() === $this) {
  393.                 $restaurant->setCourse(null);
  394.             }
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection|Accommodation[]
  402.      */
  403.     public function getAccommodations(): Collection
  404.     {
  405.         return $this->accommodations;
  406.     }
  408.     public function addAccommodation(Accommodation $accommodation): self
  409.     {
  410.         if (!$this->accommodations->contains($accommodation)) {
  411.             $this->accommodations[] = $accommodation;
  412.             $accommodation->setCourse($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeAccommodation(Accommodation $accommodation): self
  419.     {
  420.         if ($this->accommodations->removeElement($accommodation)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($accommodation->getCourse() === $this) {
  423.                 $accommodation->setCourse(null);
  424.             }
  425.         }
  427.         return $this;
  428.     }
  430.     public function getOwner(): ?User
  431.     {
  432.         return $this->owner;
  433.     }
  435.     public function setOwner(?User $owner): self
  436.     {
  437.         $this->owner = $owner;
  439.         return $this;
  440.     }
  442.     /**
  443.      * @return Collection|Sport[]
  444.      */
  445.     public function getSports(): Collection
  446.     {
  447.         return $this->sports;
  448.     }
  450.     public function addSport(Sport $sport): self
  451.     {
  452.         if (!$this->sports->contains($sport)) {
  453.             $this->sports[] = $sport;
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeSport(Sport $sport): self
  460.     {
  461.         $this->sports->removeElement($sport);
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection|CourseAvailability[]
  468.      */
  469.     public function getAvailabilities(): Collection
  470.     {
  471.         return $this->availabilities;
  472.     }
  474.     public function addAvailability(CourseAvailability $availability): self
  475.     {
  476.         if (!$this->availabilities->contains($availability)) {
  477.             $this->availabilities[] = $availability;
  478.             $availability->setCourse($this);
  479.         }
  481.         return $this;
  482.     }
  484.     public function removeAvailability(CourseAvailability $availability): self
  485.     {
  486.         if ($this->availabilities->removeElement($availability)) {
  487.             // set the owning side to null (unless already changed)
  488.             if ($availability->getCourse() === $this) {
  489.                 $availability->setCourse(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  496.     public function getFrequency(): ?string
  497.     {
  498.         return $this->frequency;
  499.     }
  501.     public function setFrequency(string $frequency): self
  502.     {
  503.         $this->frequency = $frequency;
  505.         return $this;
  506.     }
  508.     /**
  509.      * @return Collection|Language[]
  510.      */
  511.     public function getLanguages(): Collection
  512.     {
  513.         return $this->languages;
  514.     }
  516.     public function addLanguage(Language $language): self
  517.     {
  518.         if (!$this->languages->contains($language)) {
  519.             $this->languages[] = $language;
  520.         }
  522.         return $this;
  523.     }
  525.     public function removeLanguage(Language $language): self
  526.     {
  527.         $this->languages->removeElement($language);
  529.         return $this;
  530.     }
  532.     /**
  533.      * @return Collection|FeaturedCourse[]
  534.      */
  535.     public function getFeatureds(): Collection
  536.     {
  537.         return $this->featureds;
  538.     }
  540.     public function addFeatured(FeaturedCourse $featured): self
  541.     {
  542.         if (!$this->featureds->contains($featured)) {
  543.             $this->featureds[] = $featured;
  544.             $featured->setCourse($this);
  545.         }
  546.         return $this;
  547.     }
  549.     public function removeFeatured(FeaturedCourse $featured): self
  550.     {
  551.         if ($this->featureds->removeElement($featured)) {
  552.             // set the owning side to null (unless already changed)
  553.             if ($featured->getCourse() === $this) {
  554.                 $featured->setCourse(null);
  555.             }
  556.         }
  558.         return $this;
  559.     }
  561.     public function getStatus(): ?string
  562.     {
  563.         return $this->status;
  564.     }
  566.     public function setStatus(string $status): self
  567.     {
  568.         $this->status = $status;
  570.         return $this;
  571.     }
  573.     public function getCreatedAt(): ?\DateTimeInterface
  574.     {
  575.         return $this->createdAt;
  576.     }
  578.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  579.     {
  580.         $this->createdAt = $createdAt;
  582.         return $this;
  583.     }
  585.     /**
  586.      * @return Collection|Age[]
  587.      */
  588.     public function getAges(): Collection
  589.     {
  590.         return $this->ages;
  591.     }
  593.     public function addAge(Age $age): self
  594.     {
  595.         if (!$this->ages->contains($age)) {
  596.             $this->ages[] = $age;
  597.         }
  599.         return $this;
  600.     }
  602.     public function removeAge(Age $age): self
  603.     {
  604.         $this->ages->removeElement($age);
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection|Level[]
  611.      */
  612.     public function getLevels(): Collection
  613.     {
  614.         return $this->levels;
  615.     }
  617.     public function addLevel(Level $level): self
  618.     {
  619.         if (!$this->levels->contains($level)) {
  620.             $this->levels[] = $level;
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeLevel(Level $level): self
  627.     {
  628.         $this->levels->removeElement($level);
  630.         return $this;
  631.     }
  633.     /**
  634.      * @return Collection|Trainee[]
  635.      */
  636.     public function getTraineesFavorites(): Collection
  637.     {
  638.         return $this->traineesFavorites;
  639.     }
  641.     public function addTraineesFavorite(Trainee $traineesFavorite): self
  642.     {
  643.         if (!$this->traineesFavorites->contains($traineesFavorite)) {
  644.             $this->traineesFavorites[] = $traineesFavorite;
  645.             $traineesFavorite->addFavorite($this);
  646.         }
  648.         return $this;
  649.     }
  651.     public function removeTraineesFavorite(Trainee $traineesFavorite): self
  652.     {
  653.         if ($this->traineesFavorites->removeElement($traineesFavorite)) {
  654.             $traineesFavorite->removeFavorite($this);
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * @return Collection|TranslatedCourse[]
  662.      */
  663.     public function getTranslatedContents(): Collection
  664.     {
  665.         return $this->translatedContents;
  666.     }
  668.     public function addTranslatedContent(TranslatedCourse $translatedContent): self
  669.     {
  670.         if (!$this->translatedContents->contains($translatedContent)) {
  671.             $this->translatedContents[] = $translatedContent;
  672.             $translatedContent->setCourse($this);
  673.         }
  675.         return $this;
  676.     }
  678.     public function removeTranslatedContent(TranslatedCourse $translatedContent): self
  679.     {
  680.         if ($this->translatedContents->removeElement($translatedContent)) {
  681.             // set the owning side to null (unless already changed)
  682.             if ($translatedContent->getCourse() === $this) {
  683.                 $translatedContent->setCourse(null);
  684.             }
  685.         }
  687.         return $this;
  688.     }
  690.     public function getToken(): ?string
  691.     {
  692.         return $this->token;
  693.     }
  695.     public function setToken(string $token): self
  696.     {
  697.         $this->token = $token;
  699.         return $this;
  700.     }
  701.     
  702.     public function getTranslatedContent($local)
  703.     {
  704.         foreach($this->translatedContents as $translatedCourse)
  705.         {
  706.             if($translatedCourse->getLanguage() == $local)
  707.             {
  708.                 return $translatedCourse;
  709.             }
  710.         }
  711.         foreach($this->translatedContents as $translatedCourse)
  712.         {
  713.             if($translatedCourse->getLanguage() == 'en')
  714.             {
  715.                 return $translatedCourse;
  716.             }
  717.         }
  718.         return $this->getTranslatedContents()->first() ?? null;
  719.     }
  721.     /**
  722.      * @return Collection|Booking[]
  723.      */
  724.     public function getBookings(): Collection
  725.     {
  726.         return $this->bookings;
  727.     }
  729.     public function addBooking(Booking $booking): self
  730.     {
  731.         if (!$this->bookings->contains($booking)) {
  732.             $this->bookings[] = $booking;
  733.             $booking->setCourse($this);
  734.         }
  736.         return $this;
  737.     }
  739.     public function removeBooking(Booking $booking): self
  740.     {
  741.         if ($this->bookings->removeElement($booking)) {
  742.             // set the owning side to null (unless already changed)
  743.             if ($booking->getCourse() === $this) {
  744.                 $booking->setCourse(null);
  745.             }
  746.         }
  748.         return $this;
  749.     }
  751.     public function getCountryCode(): ?string
  752.     {
  753.         return $this->countryCode;
  754.     }
  756.     public function setCountryCode(string $countryCode): self
  757.     {
  758.         $this->countryCode = $countryCode;
  760.         return $this;
  761.     }
  763.     public function getLatitude(): ?float
  764.     {
  765.         return $this->latitude;
  766.     }
  768.     public function setLatitude(?float $latitude): self
  769.     {
  770.         $this->latitude = $latitude;
  772.         return $this;
  773.     }
  775.     public function getLongitude(): ?float
  776.     {
  777.         return $this->longitude;
  778.     }
  780.     public function setLongitude(?float $longitude): self
  781.     {
  782.         $this->longitude = $longitude;
  784.         return $this;
  785.     }
  787.     /**
  788.      * @return Collection|CourseViewsStat[]
  789.      */
  790.     public function getCourseViewsStats(): Collection
  791.     {
  792.         return $this->courseViewsStats;
  793.     }
  795.     public function addCourseViewsStat(CourseViewsStat $courseViewsStat): self
  796.     {
  797.         if (!$this->courseViewsStats->contains($courseViewsStat)) {
  798.             $this->courseViewsStats[] = $courseViewsStat;
  799.             $courseViewsStat->setCourse($this);
  800.         }
  802.         return $this;
  803.     }
  805.     public function removeCourseViewsStat(CourseViewsStat $courseViewsStat): self
  806.     {
  807.         if ($this->courseViewsStats->removeElement($courseViewsStat)) {
  808.             // set the owning side to null (unless already changed)
  809.             if ($courseViewsStat->getCourse() === $this) {
  810.                 $courseViewsStat->setCourse(null);
  811.             }
  812.         }
  814.         return $this;
  815.     }
  817.     public function getHideClubInfo(): ?bool
  818.     {
  819.         return $this->hideClubInfo;
  820.     }
  822.     public function setHideClubInfo(bool $hideClubInfo): self
  823.     {
  824.         $this->hideClubInfo = $hideClubInfo;
  826.         return $this;
  827.     }
  829.     public function getHideCoachInfo(): ?bool
  830.     {
  831.         return $this->hideCoachInfo;
  832.     }
  834.     public function setHideCoachInfo(bool $hideCoachInfo): self
  835.     {
  836.         $this->hideCoachInfo = $hideCoachInfo;
  838.         return $this;
  839.     }
  841.     public function getStepSaved(): ?int
  842.     {
  843.         return $this->stepSaved;
  844.     }
  846.     public function setStepSaved(?int $stepSaved): self
  847.     {
  848.         $this->stepSaved = $stepSaved;
  850.         return $this;
  851.     }
  853.     /**
  854.      * @return Collection<int, CoachInfo>
  855.      */
  856.     public function getCoachsInfos(): Collection
  857.     {
  858.         return $this->coachsInfos;
  859.     }
  861.     public function addCoachsInfo(CoachInfo $coachsInfo): self
  862.     {
  863.         if (!$this->coachsInfos->contains($coachsInfo)) {
  864.             $this->coachsInfos[] = $coachsInfo;
  865.         }
  867.         return $this;
  868.     }
  870.     public function removeCoachsInfo(CoachInfo $coachsInfo): self
  871.     {
  872.         $this->coachsInfos->removeElement($coachsInfo);
  874.         return $this;
  875.     }
  877.     public function getSendedAlert(): ?bool
  878.     {
  879.         return $this->sendedAlert;
  880.     }
  882.     public function setSendedAlert(?bool $sendedAlert): self
  883.     {
  884.         $this->sendedAlert = $sendedAlert;
  886.         return $this;
  887.     }
  889.     public function getCover()
  890.     {
  891.         return $this->cover;
  892.     }
  894.     public function setCover($cover): static
  895.     {
  896.         $this->cover = $cover;
  898.         return $this;
  899.     }
  901.     /**
  902.      * @return Collection<int, PriceBundle>
  903.      */
  904.     public function getPriceBundles(): Collection
  905.     {
  906.         return $this->priceBundles;
  907.     }
  909.     public function addPriceBundle(PriceBundle $priceBundle): static
  910.     {
  911.         if (!$this->priceBundles->contains($priceBundle)) {
  912.             $this->priceBundles->add($priceBundle);
  913.             $priceBundle->setCourse($this);
  914.         }
  916.         return $this;
  917.     }
  919.     public function removePriceBundle(PriceBundle $priceBundle): static
  920.     {
  921.         if ($this->priceBundles->removeElement($priceBundle)) {
  922.             // set the owning side to null (unless already changed)
  923.             if ($priceBundle->getCourse() === $this) {
  924.                 $priceBundle->setCourse(null);
  925.             }
  926.         }
  928.         return $this;
  929.     }
  932.     /**
  933.      * Get the value of translateName
  934.      */ 
  935.     public function getTranslateName()
  936.     {
  937.         return $this->translateName;
  938.     }
  940.     /**
  941.      * Set the value of translateName
  942.      *
  943.      * @return  self
  944.      */ 
  945.     public function setTranslateName($translateName)
  946.     {
  947.         $this->translateName = $translateName;
  949.         return $this;
  950.     }
  952.     /**
  953.      * Get the value of translateDescription
  954.      */ 
  955.     public function getTranslateDescription()
  956.     {
  957.         return $this->translateDescription;
  958.     }
  960.     /**
  961.      * Set the value of translateDescription
  962.      *
  963.      * @return  self
  964.      */ 
  965.     public function setTranslateDescription($translateDescription)
  966.     {
  967.         $this->translateDescription = $translateDescription;
  969.         return $this;
  970.     }
  972.     /**
  973.      * Get the value of translatePlanning
  974.      */ 
  975.     public function getTranslatePlanning()
  976.     {
  977.         return $this->translatePlanning;
  978.     }
  980.     /**
  981.      * Set the value of translatePlanning
  982.      *
  983.      * @return  self
  984.      */ 
  985.     public function setTranslatePlanning($translatePlanning)
  986.     {
  987.         $this->translatePlanning = $translatePlanning;
  989.         return $this;
  990.     }
  992.     /**
  993.      * Get the value of translateOther
  994.      */ 
  995.     public function getTranslateOther()
  996.     {
  997.         return $this->translateOther;
  998.     }
  1000.     /**
  1001.      * Set the value of translateOther
  1002.      *
  1003.      * @return  self
  1004.      */ 
  1005.     public function setTranslateOther($translateOther)
  1006.     {
  1007.         $this->translateOther = $translateOther;
  1009.         return $this;
  1010.     }
  1012.     public function isVisibleToClub(): ?bool
  1013.     {
  1014.         return $this->visibleToClub;
  1015.     }
  1017.     public function setVisibleToClub(?bool $visibleToClub): static
  1018.     {
  1019.         $this->visibleToClub = $visibleToClub;
  1021.         return $this;
  1022.     }
  1024.     public function isVisibleToCoach(): ?bool
  1025.     {
  1026.         return $this->visibleToCoach;
  1027.     }
  1029.     public function setVisibleToCoach(?bool $visibleToCoach): static
  1030.     {
  1031.         $this->visibleToCoach = $visibleToCoach;
  1033.         return $this;
  1034.     }
  1036.     public function isVisibleToOperator(): ?bool
  1037.     {
  1038.         return $this->visibleToOperator;
  1039.     }
  1041.     public function setVisibleToOperator(?bool $visibleToOperator): static
  1042.     {
  1043.         $this->visibleToOperator = $visibleToOperator;
  1045.         return $this;
  1046.     }
  1048.     public function getPublishedAt(): ?\DateTimeInterface
  1049.     {
  1050.         return $this->publishedAt;
  1051.     }
  1053.     public function setPublishedAt(?\DateTimeInterface $publishedAt): static
  1054.     {
  1055.         $this->publishedAt = $publishedAt;
  1057.         return $this;
  1058.     }
  1060.     public function getUpdatedAt(): ?\DateTimeInterface
  1061.     {
  1062.         return $this->updatedAt;
  1063.     }
  1065.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): static
  1066.     {
  1067.         $this->updatedAt = $updatedAt;
  1069.         return $this;
  1070.     }
  1072.     public function getOperator(): ?OperatorInfo
  1073.     {
  1074.         return $this->operator;
  1075.     }
  1077.     public function setOperator(?OperatorInfo $operator): static
  1078.     {
  1079.         $this->operator = $operator;
  1081.         return $this;
  1082.     }
  1084.     /**
  1085.      * @return Collection<int, NoteRequest>
  1086.      */
  1087.     public function getNoteRequests(): Collection
  1088.     {
  1089.         return $this->noteRequests;
  1090.     }
  1092.     public function addNoteRequest(NoteRequest $noteRequest): static
  1093.     {
  1094.         if (!$this->noteRequests->contains($noteRequest)) {
  1095.             $this->noteRequests->add($noteRequest);
  1096.             $noteRequest->setCourse($this);
  1097.         }
  1099.         return $this;
  1100.     }
  1102.     public function removeNoteRequest(NoteRequest $noteRequest): static
  1103.     {
  1104.         if ($this->noteRequests->removeElement($noteRequest)) {
  1105.             // set the owning side to null (unless already changed)
  1106.             if ($noteRequest->getCourse() === $this) {
  1107.                 $noteRequest->setCourse(null);
  1108.             }
  1109.         }
  1111.         return $this;
  1112.     }
  1114.     /**
  1115.      * @return Collection<int, Note>
  1116.      */
  1117.     public function getNotes(): Collection
  1118.     {
  1119.         return $this->notes;
  1120.     }
  1122.     public function addNote(Note $note): static
  1123.     {
  1124.         if (!$this->notes->contains($note)) {
  1125.             $this->notes->add($note);
  1126.             $note->setCourse($this);
  1127.         }
  1129.         return $this;
  1130.     }
  1132.     public function removeNote(Note $note): static
  1133.     {
  1134.         if ($this->notes->removeElement($note)) {
  1135.             // set the owning side to null (unless already changed)
  1136.             if ($note->getCourse() === $this) {
  1137.                 $note->setCourse(null);
  1138.             }
  1139.         }
  1141.         return $this;
  1142.     }
  1143. }