src/Entity/Product.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\ReseauSociaux\Publication;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Repository\ProductRepository;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Symfony\Component\Serializer\Annotation\Groups;
  11. use Symfony\Component\Validator\Constraints as Assert;
  13. /**
  14.  * @ORM\Entity(repositoryClass=ProductRepository::class)
  15.  */
  16. class Product
  17. {
  18.     /**
  19.      * @ORM\Id()
  20.      * @ORM\GeneratedValue()
  21.      * @ORM\Column(type="integer")
  22.      * @Groups({"product:read", "publication:read", "post:read"})
  23.      */
  24.     private $id;
  26.     /**
  27.      * @ORM\Column(type="string", length=255)
  28.      * @Groups("post:read","product:read","publication:read")
  29.      */
  30.     private $name;
  32.     /**
  33.      * @ORM\Column(type="text")
  34.      */
  35.     private $text;
  37.     /**
  38.      * @ORM\Column(type="float", nullable=true)
  39.      * @Groups({"product:read"})
  40.      */
  41.     private $price;
  43.     /**
  44.      * @ORM\Column(type="integer", nullable=true)
  45.      */
  46.     private $quantity;
  48.     /**
  49.      * @ORM\OneToMany(targetEntity=Photos::class, mappedBy="product", cascade={"persist", "remove"})
  50.      * @Assert\NotBlank(message="Veuillez ajouter au moins une photo au produit")
  51.      * @Groups("post:read","product:read")
  52.      */
  53.     private $photos;
  55.     /**
  56.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="products")
  57.      */
  58.     private $company;
  60.     /**
  61.      * @ORM\Column(type="string", length=255)
  62.      * @Groups("publication:read","post:read")
  63.      */
  64.     private $productSlug;
  66.     /**
  67.      * @ORM\Column(type="integer", nullable=true, options={"default" : 50})
  68.      */
  69.     private $percentDeposit;
  71.     /**
  72.      * @ORM\Column(type="integer", nullable=true, options={"default" : 0})
  73.      */
  74.     private $deadline;
  76.     /**
  77.      * @ORM\ManyToMany(targetEntity=Department::class, inversedBy="products")
  78.      */
  79.     private $departments;
  81.     /**
  82.      * @ORM\Column(type="array", nullable=true)
  83.      */
  84.     private $sizes = [];
  86.     /**
  87.      * @ORM\Column(type="array", nullable=true)
  88.      */
  89.     private $colors = [];
  91.     /**
  92.      * @ORM\Column(type="array", nullable=true)
  93.      */
  94.     private $sizeRing = [];
  96.     /**
  97.      * @ORM\OneToMany(targetEntity=CommandProduct::class, mappedBy="product")
  98.      */
  99.     private $commandProducts;
  101.     /**
  102.      * @ORM\OneToMany(targetEntity=Avis::class, mappedBy="product")
  103.      */
  104.     private $avis;
  106.     /**
  107.      * @ORM\ManyToOne(targetEntity=Pack::class, inversedBy="products")
  108.      */
  109.     private $pack;
  111.     /**
  112.      * @ORM\Column(type="integer", nullable=true)
  113.      */
  114.     private $nbGuest;
  116.     /**
  117.      * @ORM\Column(type="text", nullable=true)
  118.      */
  119.     private $youtubeVideo;
  121.     /**
  122.      * @ORM\Column(type="boolean")
  123.      */
  124.     private $isActivated;
  126.     /**
  127.      * @ORM\Column(type="boolean")
  128.      */
  129.     private $isDesactivatedByAdmin;
  131.     /**
  132.      * @ORM\Column(type="array", nullable=true)
  133.      */
  134.     private $modeLivraison;
  136.     /**
  137.      * @ORM\Column(type="float", nullable=true)
  138.      */
  139.     private $fraisLivraison;
  141.     /**
  142.      * @ORM\OneToMany(targetEntity=ProductPercent::class, mappedBy="product")
  143.      */
  144.     private $productPercents;
  146.     /**
  147.      * @ORM\OneToMany(targetEntity=ContactProduct::class, mappedBy="product")
  148.      */
  149.     private $contactProducts;
  151.     /**
  152.      * @ORM\OneToMany(targetEntity=ProductOption::class, mappedBy="product", orphanRemoval=true, cascade={"persist", "remove"})
  153.      */
  154.     private $productOptions;
  156.     /**
  157.      * @ORM\ManyToMany(targetEntity=SubCategory::class, inversedBy="products")
  158.      * @Groups("publication:read", "post:read")
  159.      */
  160.     private $subCategories;
  162.     /**
  163.      * @ORM\Column(type="string", length=255, nullable=true)
  164.      */
  165.     private $weight;
  167.     /**
  168.      * @ORM\Column(type="array", nullable=true)
  169.      */
  170.     private $transporteurs = [];
  172.     /**
  173.      * @ORM\Column(type="string", length=20, nullable=true)
  174.      */
  175.     private $codePromo;
  177.     /**
  178.      * @ORM\Column(type="float", nullable=true)
  179.      */
  180.     private $codePromoEuro;
  182.     /**
  183.      * @ORM\OneToOne(targetEntity=ProductDescription::class, mappedBy="product", cascade={"persist", "remove"})
  184.      */
  185.     private $productDescription;
  187.     /**
  188.      * @ORM\Column(type="integer", nullable=true)
  189.      */
  190.     private $template;
  192.     /**
  193.      * @ORM\OneToMany(targetEntity=AnnonceCompany::class, mappedBy="products")
  194.      */
  195.     private $annonceCompanies;
  197.     /**
  198.      * @ORM\ManyToOne(targetEntity=TypeLocation::class, inversedBy="products")
  199.      */
  200.     private $typeLocation;
  202.     /**
  203.      * @ORM\ManyToOne(targetEntity=TypePrestation::class, inversedBy="products")
  204.      */
  205.     private $typePrestation;
  207.     /**
  208.      * @ORM\OneToMany(targetEntity=Location::class, mappedBy="product", orphanRemoval=true)
  209.      */
  210.     private $locations;
  212.     /**
  213.      * @ORM\OneToMany(targetEntity=Reservation::class, mappedBy="product", orphanRemoval=true)
  214.      */
  215.     private $reservations;
  218.     /**
  219.      * @ORM\ManyToOne(targetEntity=Tva::class, inversedBy="products")
  220.      */
  221.     private $tva;
  223.     /**
  224.      * @ORM\OneToMany(targetEntity=Caution::class, mappedBy="product")
  225.      */
  226.     private $cautions;
  228.     /**
  229.      * @ORM\OneToMany(targetEntity=Participant::class, mappedBy="produit")
  230.      */
  231.     private $participants;
  233.     /** 
  234.      * @ORM\ManyToOne(targetEntity=TypeHebergement::class, cascade={"persist"})
  235.      */
  236.     private $typeHebergements;
  238.     /**
  239.      * @ORM\OneToMany(targetEntity=Chambre::class, mappedBy="product", orphanRemoval=true, cascade={"persist"})
  240.      */
  241.     private $chambres;
  243.     /**
  244.      * @ORM\ManyToMany(targetEntity=Caracteristic::class, mappedBy="product")
  245.      */
  246.     private $caracteristics;
  248.     /**
  249.      * @ORM\ManyToMany(targetEntity=Equipment::class, mappedBy="product")
  250.      */
  251.     private $equipment;
  253.     /**
  254.      * @ORM\ManyToMany(targetEntity=LangueHote::class, mappedBy="product")
  255.      */
  256.     private $langueHotes;
  258.     /**
  259.      * @ORM\ManyToMany(targetEntity=TypeLocalisation::class, mappedBy="product")
  260.      */
  261.     private $typeLocalisations;
  263.     /**
  264.      * @ORM\ManyToMany(targetEntity=Security::class, mappedBy="product")
  265.      */
  266.     private $securities;
  268.     /**
  269.      * @ORM\Column(type="float", nullable=true)
  270.      */
  271.     private $taxeSejour;
  273.     /**
  274.      * @ORM\Column(type="float", nullable=true)
  275.      */
  276.     private $prixCaution;
  278.     /**
  279.      * @ORM\Column(type="float", nullable=true)
  280.      */
  281.     private $longitude;
  283.     /**
  284.      * @ORM\Column(type="float", nullable=true)
  285.      */
  286.     private $latitude;
  288.     /**
  289.      * @ORM\ManyToOne(targetEntity=ActivityType::class)
  290.      */
  291.     private $typeActivity;
  293.     /**
  294.      * @ORM\OneToMany(targetEntity=ProductReduction::class, mappedBy="Product", orphanRemoval=true, cascade={"persist", "remove"})
  295.      */
  296.     private $productReductions;
  298.     /**
  299.      * @ORM\Column(type="float", nullable=true)
  300.      */
  301.     private $springPrice;
  303.     /**
  304.      * @ORM\Column(type="float", nullable=true)
  305.      */
  306.     private $summerPrice;
  308.     /**
  309.      * @ORM\Column(type="float", nullable=true)
  310.      */
  311.     private $autumnPrice;
  313.     /**
  314.      * @ORM\Column(type="float", nullable=true)
  315.      */
  316.     private $winterPrice;
  318.     /**
  319.      * @ORM\Column(type="float", nullable=true)
  320.      */
  321.     private $weekEndPrice;
  323.     /**
  324.      * @ORM\OneToMany(targetEntity=ProgrammingDayPrice::class, mappedBy="product", orphanRemoval=true, cascade={"persist"})
  325.      */
  326.     private $dayPrice;
  328.     /**
  329.      * @ORM\OneToMany(targetEntity=ProductAgenda::class, mappedBy="product", orphanRemoval=true, cascade={"persist"})
  330.      */
  331.     private $productAgendas;
  333.     /**
  334.      * @ORM\OneToMany(targetEntity=ProductAutoReduction::class, mappedBy="Product", orphanRemoval=true, cascade={"persist"})
  335.      */
  336.     private $productAutoReduction;
  338.     /**
  339.      * @ORM\OneToMany(targetEntity=Publication::class, mappedBy="product_company")
  340.      */
  341.     private $publications;
  343.     /**
  344.      * @ORM\OneToMany(targetEntity=PendingLocation::class, mappedBy="product")
  345.      */
  346.     private $pendingLocations;
  348.     /**
  349.      * @ORM\OneToMany(targetEntity=PendingReservation::class, mappedBy="product")
  350.      */
  351.     private $pendingReservations;
  353.     /**
  354.      * @ORM\OneToMany(targetEntity=ProductPeriodPrice::class, mappedBy="product", orphanRemoval=true, cascade={"persist"})
  355.      */
  356.     private $periodPrice;
  358.     /**
  359.      * @ORM\Column(type="string", length=255, nullable=true)
  360.      */
  361.     private $cityLocalisation;
  363.     /**
  364.      * @ORM\Column(type="integer", nullable=true)
  365.      */
  366.     private ?int $nbChambre = null;
  368.     /**
  369.      * @ORM\Column(type="integer", nullable=true)
  370.      */
  371.     private $nightMin;
  373.     /**
  374.      * @ORM\OneToMany(targetEntity=TarifDegressif::class, mappedBy="Product", orphanRemoval=true, cascade={"persist", "remove"})
  375.      */
  376.     private $tarifDegressifs;
  378.     /**
  379.      * @ORM\ManyToMany(targetEntity=EquipementsCuisine::class, mappedBy="product")
  380.      */
  381.     private $equipementsCuisines;
  383.     /**
  384.      * @ORM\ManyToMany(targetEntity=SalleDeBain::class, mappedBy="product")
  385.      */
  386.     private $salleDeBains;
  388.     /**
  389.      * @ORM\ManyToMany(targetEntity=AccessoiresDeChambre::class, mappedBy="product")
  390.      */
  391.     private $accessoiresDeChambres;
  393.     /**
  394.      * @ORM\ManyToMany(targetEntity=MobilierExterieur::class, mappedBy="product")
  395.      */
  396.     private $mobilierExterieurs;
  398.     /**
  399.      * @ORM\ManyToOne(targetEntity=CaracteristiqueVehicule::class, inversedBy="products", cascade={"persist"})
  400.      */
  401.     private $caracteristiqueVehicule;
  403.     /**
  404.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="product")
  405.      */
  406.     private $notificationReservation;
  408.     /**
  409.      * @ORM\ManyToOne(targetEntity=Commune::class, inversedBy="products")
  410.      */
  411.     private $commune;
  413.     public function __construct()
  414.     {
  415.         $this->photos = new ArrayCollection();
  416.         $this->departments = new ArrayCollection();
  417.         $this->commandProducts = new ArrayCollection();
  418.         $this->avis = new ArrayCollection();
  419.         $this->isActivated = true;
  420.         $this->isDesactivatedByAdmin = false;
  421.         $this->productPercents = new ArrayCollection();
  422.         $this->contactProducts = new ArrayCollection();
  423.         $this->productOptions = new ArrayCollection();
  424.         $this->subCategories = new ArrayCollection();
  425.         $this->annonceCompanies = new ArrayCollection();
  426.         $this->locations = new ArrayCollection();
  427.         $this->reservations = new ArrayCollection();
  428.         $this->cautions = new ArrayCollection();
  429.         $this->participants = new ArrayCollection();
  430.         $this->chambres = new ArrayCollection();
  431.         $this->caracteristics = new ArrayCollection();
  432.         $this->equipment = new ArrayCollection();
  433.         $this->langueHotes = new ArrayCollection();
  434.         $this->typeLocalisations = new ArrayCollection();
  435.         $this->securities = new ArrayCollection();
  436.         $this->productReductions = new ArrayCollection();
  437.         $this->dayPrice = new ArrayCollection();
  438.         $this->productAgendas = new ArrayCollection();
  439.         $this->productAutoReduction = new ArrayCollection();
  440.         $this->publications = new ArrayCollection();
  441.         $this->pendingLocations = new ArrayCollection();
  442.         $this->pendingReservations = new ArrayCollection();
  443.         $this->periodPrice = new ArrayCollection();
  444.         $this->tarifDegressifs = new ArrayCollection();
  445.         $this->equipementsCuisines = new ArrayCollection();
  446.         $this->salleDeBains = new ArrayCollection();
  447.         $this->accessoiresDeChambres = new ArrayCollection();
  448.         $this->mobilierExterieurs = new ArrayCollection();
  449.         $this->notificationReservation = new ArrayCollection();
  450.     }
  452.     public function getId(): ?int
  453.     {
  454.         return $this->id;
  455.     }
  457.     public function getPercentDeposit(): ?int
  458.     {
  459.         return $this->percentDeposit;
  460.     }
  462.     public function setPercentDeposit(?int $percentDeposit): self
  463.     {
  464.         $this->percentDeposit = $percentDeposit;
  466.         return $this;
  467.     }
  469.     public function getDeadline(): ?int
  470.     {
  471.         return $this->deadline;
  472.     }
  474.     public function setDeadline(?int $deadline): self
  475.     {
  476.         $this->deadline = $deadline;
  478.         return $this;
  479.     }
  481.     public function getName(): ?string
  482.     {
  483.         return $this->name;
  484.     }
  486.     public function setName(?string $name): self
  487.     {
  488.         $this->name = $name;
  490.         return $this;
  491.     }
  493.     public function getText(): ?string
  494.     {
  495.         return $this->text;
  496.     }
  498.     public function setText(?string $text): self
  499.     {
  500.         $this->text = $text;
  502.         return $this;
  503.     }
  505.     public function getPrice(): ?float
  506.     {
  507.         return $this->price;
  508.     }
  510.     public function setPrice(float $price): self
  511.     {
  512.         $this->price = $price;
  514.         return $this;
  515.     }
  517.     public function getQuantity(): ?int
  518.     {
  519.         return $this->quantity;
  520.     }
  522.     public function setQuantity(?int $quantity): self
  523.     {
  524.         $this->quantity = $quantity;
  526.         return $this;
  527.     }
  529.     /**
  530.      * @return Collection|Photos[]
  531.      */
  532.     public function getPhotos(): Collection
  533.     {
  534.         return $this->photos;
  535.     }
  537.     public function addPhoto(Photos $photo): self
  538.     {
  539.         if (!$this->photos->contains($photo)) {
  540.             $this->photos[] = $photo;
  541.             $photo->setProduct($this);
  542.         }
  544.         return $this;
  545.     }
  547.     public function removePhoto(Photos $photo): self
  548.     {
  549.         if ($this->photos->contains($photo)) {
  550.             $this->photos->removeElement($photo);
  551.             // set the owning side to null (unless already changed)
  552.             if ($photo->getProduct() === $this) {
  553.                 $photo->setProduct(null);
  554.             }
  555.         }
  557.         return $this;
  558.     }
  560.     public function getCompany(): ?Company
  561.     {
  562.         return $this->company;
  563.     }
  565.     public function setCompany(?Company $company): self
  566.     {
  567.         $this->company = $company;
  569.         return $this;
  570.     }
  572.     /**
  573.      * @return mixed
  574.      */
  575.     public function getProductSlug()
  576.     {
  577.         return $this->productSlug;
  578.     }
  580.     /**
  581.      * @param mixed $productSlug
  582.      */
  583.     public function setProductSlug($productSlug): void
  584.     {
  585.         $this->productSlug = $productSlug;
  586.     }
  588.     /**
  589.      * @return Collection|Department[]
  590.      */
  591.     public function getDepartments(): Collection
  592.     {
  593.         return $this->departments;
  594.     }
  596.     public function addDepartment(Department $department): self
  597.     {
  598.         if (!$this->departments->contains($department)) {
  599.             $this->departments[] = $department;
  600.         }
  602.         return $this;
  603.     }
  605.     public function removeDepartment(Department $department): self
  606.     {
  607.         if ($this->departments->contains($department)) {
  608.             $this->departments->removeElement($department);
  609.         }
  611.         return $this;
  612.     }
  614.     public function getSizes(): ?array
  615.     {
  616.         return $this->sizes;
  617.     }
  619.     public function setSizes(?array $sizes): self
  620.     {
  621.         $this->sizes = $sizes;
  623.         return $this;
  624.     }
  626.     /**
  627.      * @return Collection|CommandProduct[]
  628.      */
  629.     public function getCommandProducts(): Collection
  630.     {
  631.         return $this->commandProducts;
  632.     }
  634.     public function addCommandProduct(CommandProduct $commandProduct): self
  635.     {
  636.         if (!$this->commandProducts->contains($commandProduct)) {
  637.             $this->commandProducts[] = $commandProduct;
  638.             $commandProduct->setProduct($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeCommandProduct(CommandProduct $commandProduct): self
  645.     {
  646.         if ($this->commandProducts->contains($commandProduct)) {
  647.             $this->commandProducts->removeElement($commandProduct);
  648.             // set the owning side to null (unless already changed)
  649.             if ($commandProduct->getProduct() === $this) {
  650.                 $commandProduct->setProduct(null);
  651.             }
  652.         }
  654.         return $this;
  655.     }
  657.     /**
  658.      * @return Collection|Avis[]
  659.      */
  660.     public function getAvis(): Collection
  661.     {
  662.         return $this->avis;
  663.     }
  665.     public function addAvi(Avis $avi): self
  666.     {
  667.         if (!$this->avis->contains($avi)) {
  668.             $this->avis[] = $avi;
  669.             $avi->setProduct($this);
  670.         }
  672.         return $this;
  673.     }
  675.     public function removeAvi(Avis $avi): self
  676.     {
  677.         if ($this->avis->contains($avi)) {
  678.             $this->avis->removeElement($avi);
  679.             // set the owning side to null (unless already changed)
  680.             if ($avi->getProduct() === $this) {
  681.                 $avi->setProduct(null);
  682.             }
  683.         }
  685.         return $this;
  686.     }
  688.     public function getPack(): ?Pack
  689.     {
  690.         return $this->pack;
  691.     }
  693.     public function setPack(?Pack $pack): self
  694.     {
  695.         $this->pack = $pack;
  697.         return $this;
  698.     }
  700.     public function getNbGuest(): ?int
  701.     {
  702.         return $this->nbGuest;
  703.     }
  705.     public function setNbGuest(?int $nbGuest): self
  706.     {
  707.         $this->nbGuest = $nbGuest;
  709.         return $this;
  710.     }
  712.     public function getYoutubeVideo(): ?string
  713.     {
  714.         return $this->youtubeVideo;
  715.     }
  717.     public function setYoutubeVideo(?string $youtubeVideo): self
  718.     {
  719.         $this->youtubeVideo = $youtubeVideo;
  721.         return $this;
  722.     }
  724.     public function getIsActivated(): ?bool
  725.     {
  726.         return $this->isActivated;
  727.     }
  729.     public function setIsActivated(bool $isActivated): self
  730.     {
  731.         $this->isActivated = $isActivated;
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return false
  738.      */
  739.     public function getIsDesactivatedByAdmin(): bool
  740.     {
  741.         return $this->isDesactivatedByAdmin;
  742.     }
  744.     /**
  745.      * @param false $isDesactivatedByAdmin
  746.      * @return Product
  747.      */
  748.     public function setIsDesactivatedByAdmin(bool $isDesactivatedByAdmin): Product
  749.     {
  750.         $this->isDesactivatedByAdmin = $isDesactivatedByAdmin;
  751.         return $this;
  752.     }
  754.     public function getModeLivraison(): ?array
  755.     {
  756.         return $this->modeLivraison;
  757.     }
  759.     public function setModeLivraison(?array $modeLivraison): self
  760.     {
  761.         $this->modeLivraison = $modeLivraison;
  763.         return $this;
  764.     }
  766.     public function getFraisLivraison(): ?float
  767.     {
  768.         return $this->fraisLivraison;
  769.     }
  771.     public function setFraisLivraison(?float $fraisLivraison): self
  772.     {
  773.         $this->fraisLivraison = $fraisLivraison;
  775.         return $this;
  776.     }
  778.     public function getColors(): ?array
  779.     {
  780.         return $this->colors;
  781.     }
  783.     public function setColors(?array $colors): self
  784.     {
  785.         $this->colors = $colors;
  787.         return $this;
  788.     }
  790.     /**
  791.      * @return Collection|ProductPercent[]
  792.      */
  793.     public function getProductPercents(): Collection
  794.     {
  795.         return $this->productPercents;
  796.     }
  798.     public function addProductPercent(ProductPercent $productPercent): self
  799.     {
  800.         if (!$this->productPercents->contains($productPercent)) {
  801.             $this->productPercents[] = $productPercent;
  802.             $productPercent->setProduct($this);
  803.         }
  805.         return $this;
  806.     }
  808.     public function removeProductPercent(ProductPercent $productPercent): self
  809.     {
  810.         if ($this->productPercents->contains($productPercent)) {
  811.             $this->productPercents->removeElement($productPercent);
  812.             // set the owning side to null (unless already changed)
  813.             if ($productPercent->getProduct() === $this) {
  814.                 $productPercent->setProduct(null);
  815.             }
  816.         }
  818.         return $this;
  819.     }
  821.     public function getProductNamePrice()
  822.     {
  823.         return $this->name . ' - ' . $this->price . '€ - ' . $this->getCompany()->getCompanyName();
  824.     }
  826.     public function getSizeRing(): ?array
  827.     {
  828.         return $this->sizeRing;
  829.     }
  831.     public function setSizeRing(?array $sizeRing): self
  832.     {
  833.         $this->sizeRing = $sizeRing;
  835.         return $this;
  836.     }
  838.     /**
  839.      * @return Collection|ContactProduct[]
  840.      */
  841.     public function getContactProducts(): Collection
  842.     {
  843.         return $this->contactProducts;
  844.     }
  846.     public function addContactProduct(ContactProduct $contactProduct): self
  847.     {
  848.         if (!$this->contactProducts->contains($contactProduct)) {
  849.             $this->contactProducts[] = $contactProduct;
  850.             $contactProduct->setProduct($this);
  851.         }
  853.         return $this;
  854.     }
  856.     public function removeContactProduct(ContactProduct $contactProduct): self
  857.     {
  858.         if ($this->contactProducts->contains($contactProduct)) {
  859.             $this->contactProducts->removeElement($contactProduct);
  860.             // set the owning side to null (unless already changed)
  861.             if ($contactProduct->getProduct() === $this) {
  862.                 $contactProduct->setProduct(null);
  863.             }
  864.         }
  866.         return $this;
  867.     }
  869.     /**
  870.      * @return Collection|ProductOption[]
  871.      */
  872.     public function getProductOptions(): Collection
  873.     {
  874.         return $this->productOptions;
  875.     }
  877.     public function addProductOption(ProductOption $productOption): self
  878.     {
  879.         if (!$this->productOptions->contains($productOption)) {
  880.             $this->productOptions[] = $productOption;
  881.             $productOption->setProduct($this);
  882.         }
  884.         return $this;
  885.     }
  887.     public function removeProductOption(ProductOption $productOption): self
  888.     {
  889.         if ($this->productOptions->removeElement($productOption)) {
  890.             // set the owning side to null (unless already changed)
  891.             if ($productOption->getProduct() === $this) {
  892.                 $productOption->setProduct(null);
  893.             }
  894.         }
  896.         return $this;
  897.     }
  899.     /**
  900.      * @return Collection|SubCategory[]
  901.      */
  902.     public function getSubCategories(): Collection
  903.     {
  904.         return $this->subCategories;
  905.     }
  907.     public function addSubCategory(SubCategory $subCategory): self
  908.     {
  909.         if (!$this->subCategories->contains($subCategory)) {
  910.             $this->subCategories[] = $subCategory;
  911.         }
  913.         return $this;
  914.     }
  916.     public function removeSubCategory(SubCategory $subCategory): self
  917.     {
  918.         $this->subCategories->removeElement($subCategory);
  920.         return $this;
  921.     }
  923.     public function getWeight(): ?string
  924.     {
  925.         return $this->weight;
  926.     }
  928.     public function setWeight(?string $weight): self
  929.     {
  930.         $this->weight = $weight;
  932.         return $this;
  933.     }
  935.     public function getTransporteurs(): ?array
  936.     {
  937.         return $this->transporteurs;
  938.     }
  940.     public function setTransporteurs(?array $transporteurs): self
  941.     {
  942.         $this->transporteurs = $transporteurs;
  944.         return $this;
  945.     }
  947.     public function getCodePromo(): ?string
  948.     {
  949.         return $this->codePromo;
  950.     }
  952.     public function setCodePromo(?string $codePromo): self
  953.     {
  954.         $this->codePromo = $codePromo;
  956.         return $this;
  957.     }
  959.     public function getCodePromoEuro(): ?float
  960.     {
  961.         return $this->codePromoEuro;
  962.     }
  964.     public function setCodePromoEuro(?float $codePromoEuro): self
  965.     {
  966.         $this->codePromoEuro = $codePromoEuro;
  968.         return $this;
  969.     }
  971.     public function getProductDescription(): ?ProductDescription
  972.     {
  973.         return $this->productDescription;
  974.     }
  976.     public function setProductDescription(?ProductDescription $productDescription): self
  977.     {
  978.         // unset the owning side of the relation if necessary
  979.         if ($productDescription === null && $this->productDescription !== null) {
  980.             $this->productDescription->setProduct(null);
  981.         }
  983.         // set the owning side of the relation if necessary
  984.         if ($productDescription !== null && $productDescription->getProduct() !== $this) {
  985.             $productDescription->setProduct($this);
  986.         }
  988.         $this->productDescription = $productDescription;
  990.         return $this;
  991.     }
  993.     public function getTemplate(): ?int
  994.     {
  995.         return $this->template;
  996.     }
  998.     public function setTemplate(?int $template): self
  999.     {
  1000.         $this->template = $template;
  1002.         return $this;
  1003.     }
  1005.     /**
  1006.      * @return Collection|AnnonceCompany[]
  1007.      */
  1008.     public function getAnnonceCompanies(): Collection
  1009.     {
  1010.         return $this->annonceCompanies;
  1011.     }
  1013.     public function addAnnonceCompany(AnnonceCompany $annonceCompany): self
  1014.     {
  1015.         if (!$this->annonceCompanies->contains($annonceCompany)) {
  1016.             $this->annonceCompanies[] = $annonceCompany;
  1017.             $annonceCompany->setProducts($this);
  1018.         }
  1020.         return $this;
  1021.     }
  1023.     public function removeAnnonceCompany(AnnonceCompany $annonceCompany): self
  1024.     {
  1025.         if ($this->annonceCompanies->removeElement($annonceCompany)) {
  1026.             // set the owning side to null (unless already changed)
  1027.             if ($annonceCompany->getProducts() === $this) {
  1028.                 $annonceCompany->setProducts(null);
  1029.             }
  1030.         }
  1032.         return $this;
  1033.     }
  1035.     public function getTypeLocation(): ?TypeLocation
  1036.     {
  1037.         return $this->typeLocation;
  1038.     }
  1040.     public function setTypeLocation(?TypeLocation $typeLocation): self
  1041.     {
  1042.         $this->typeLocation = $typeLocation;
  1044.         return $this;
  1045.     }
  1047.     public function getTypePrestation(): ?TypePrestation
  1048.     {
  1049.         return $this->typePrestation;
  1050.     }
  1052.     public function setTypePrestation(?TypePrestation $typePrestation): self
  1053.     {
  1054.         $this->typePrestation = $typePrestation;
  1056.         return $this;
  1057.     }
  1059.     /**
  1060.      * @return Collection|Location[]
  1061.      */
  1062.     public function getLocations(): Collection
  1063.     {
  1064.         return $this->locations;
  1065.     }
  1067.     public function addLocation(Location $location): self
  1068.     {
  1069.         if (!$this->locations->contains($location)) {
  1070.             $this->locations[] = $location;
  1071.             $location->setProduct($this);
  1072.         }
  1074.         return $this;
  1075.     }
  1077.     public function removeLocation(Location $location): self
  1078.     {
  1079.         if ($this->locations->removeElement($location)) {
  1080.             // set the owning side to null (unless already changed)
  1081.             if ($location->getProduct() === $this) {
  1082.                 $location->setProduct(null);
  1083.             }
  1084.         }
  1086.         return $this;
  1087.     }
  1089.     /**
  1090.      * @return Collection|Reservation[]
  1091.      */
  1092.     public function getReservations(): Collection
  1093.     {
  1094.         return $this->reservations;
  1095.     }
  1097.     public function addReservation(Reservation $reservation): self
  1098.     {
  1099.         if (!$this->reservations->contains($reservation)) {
  1100.             $this->reservations[] = $reservation;
  1101.             $reservation->setProduct($this);
  1102.         }
  1104.         return $this;
  1105.     }
  1107.     public function removeReservation(Reservation $reservation): self
  1108.     {
  1109.         if ($this->reservations->removeElement($reservation)) {
  1110.             // set the owning side to null (unless already changed)
  1111.             if ($reservation->getProduct() === $this) {
  1112.                 $reservation->setProduct(null);
  1113.             }
  1114.         }
  1116.         return $this;
  1117.     }
  1120.     public function getTva(): ?Tva
  1121.     {
  1122.         return $this->tva;
  1123.     }
  1125.     public function setTva(?Tva $tva): self
  1126.     {
  1127.         $this->tva = $tva;
  1129.         return $this;
  1130.     }
  1132.     /**
  1133.      * @return Collection|Caution[]
  1134.      */
  1135.     public function getCautions(): Collection
  1136.     {
  1137.         return $this->cautions;
  1138.     }
  1140.     public function addCaution(Caution $caution): self
  1141.     {
  1142.         if (!$this->cautions->contains($caution)) {
  1143.             $this->cautions[] = $caution;
  1144.             $caution->setProduct($this);
  1145.         }
  1147.         return $this;
  1148.     }
  1150.     public function removeCaution(Caution $caution): self
  1151.     {
  1152.         if ($this->cautions->removeElement($caution)) {
  1153.             // set the owning side to null (unless already changed)
  1154.             if ($caution->getProduct() === $this) {
  1155.                 $caution->setProduct(null);
  1156.             }
  1157.         }
  1159.         return $this;
  1160.     }
  1162.     /**
  1163.      * @return Collection|Participant[]
  1164.      */
  1165.     public function getParticipants(): Collection
  1166.     {
  1167.         return $this->participants;
  1168.     }
  1170.     public function addParticipant(Participant $participant): self
  1171.     {
  1172.         if (!$this->participants->contains($participant)) {
  1173.             $this->participants[] = $participant;
  1174.             $participant->setProduit($this);
  1175.         }
  1177.         return $this;
  1178.     }
  1180.     public function removeParticipant(Participant $participant): self
  1181.     {
  1182.         if ($this->participants->removeElement($participant)) {
  1183.             // set the owning side to null (unless already changed)
  1184.             if ($participant->getProduit() === $this) {
  1185.                 $participant->setProduit(null);
  1186.             }
  1187.         }
  1189.         return $this;
  1190.     }
  1192.     public function getTypeHebergements(): ?TypeHebergement
  1193.     {
  1194.         return $this->typeHebergements;
  1195.     }
  1197.     public function setTypeHebergements(?TypeHebergement $typeHebergements): self
  1198.     {
  1199.         $this->typeHebergements = $typeHebergements;
  1201.         return $this;
  1202.     }
  1204.     /**
  1205.      * @return Collection|Chambre[]
  1206.      */
  1207.     public function getChambres(): Collection
  1208.     {
  1209.         return $this->chambres;
  1210.     }
  1212.     public function addChambre(Chambre $chambre): self
  1213.     {
  1214.         if (!$this->chambres->contains($chambre)) {
  1215.             $this->chambres[] = $chambre;
  1216.             $chambre->setProduct($this);
  1217.         }
  1219.         return $this;
  1220.     }
  1222.     public function removeChambre(Chambre $chambre): self
  1223.     {
  1224.         $this->chambres->removeElement($chambre);
  1226.         return $this;
  1227.     }
  1229.     /**
  1230.      * @return Collection|Caracteristic[]
  1231.      */
  1232.     public function getCaracteristics(): Collection
  1233.     {
  1234.         return $this->caracteristics;
  1235.     }
  1237.     public function addCaracteristic(Caracteristic $caracteristic): self
  1238.     {
  1239.         if (!$this->caracteristics->contains($caracteristic)) {
  1240.             $this->caracteristics[] = $caracteristic;
  1241.             $caracteristic->addProduct($this);
  1242.         }
  1244.         return $this;
  1245.     }
  1247.     public function removeCaracteristic(Caracteristic $caracteristic): self
  1248.     {
  1249.         if ($this->caracteristics->removeElement($caracteristic)) {
  1250.             $caracteristic->removeProduct($this);
  1251.         }
  1253.         return $this;
  1254.     }
  1256.     /**
  1257.      * @return Collection|Equipment[]
  1258.      */
  1259.     public function getEquipment(): Collection
  1260.     {
  1261.         return $this->equipment;
  1262.     }
  1264.     public function addEquipment(Equipment $equipment): self
  1265.     {
  1266.         if (!$this->equipment->contains($equipment)) {
  1267.             $this->equipment[] = $equipment;
  1268.             $equipment->addProduct($this);
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     public function removeEquipment(Equipment $equipment): self
  1275.     {
  1276.         if ($this->equipment->removeElement($equipment)) {
  1277.             $equipment->removeProduct($this);
  1278.         }
  1280.         return $this;
  1281.     }
  1283.     /**
  1284.      * @return Collection|LangueHote[]
  1285.      */
  1286.     public function getLangueHotes(): Collection
  1287.     {
  1288.         return $this->langueHotes;
  1289.     }
  1291.     public function addLangueHote(LangueHote $langueHote): self
  1292.     {
  1293.         if (!$this->langueHotes->contains($langueHote)) {
  1294.             $this->langueHotes[] = $langueHote;
  1295.             $langueHote->addProduct($this);
  1296.         }
  1298.         return $this;
  1299.     }
  1301.     public function removeLangueHote(LangueHote $langueHote): self
  1302.     {
  1303.         if ($this->langueHotes->removeElement($langueHote)) {
  1304.             $langueHote->removeProduct($this);
  1305.         }
  1307.         return $this;
  1308.     }
  1310.     /**
  1311.      * @return Collection|TypeLocalisation[]
  1312.      */
  1313.     public function getTypeLocalisations(): Collection
  1314.     {
  1315.         return $this->typeLocalisations;
  1316.     }
  1318.     public function addTypeLocalisation(TypeLocalisation $typeLocalisation): self
  1319.     {
  1320.         if (!$this->typeLocalisations->contains($typeLocalisation)) {
  1321.             $this->typeLocalisations[] = $typeLocalisation;
  1322.             $typeLocalisation->addProduct($this);
  1323.         }
  1325.         return $this;
  1326.     }
  1328.     public function removeTypeLocalisation(TypeLocalisation $typeLocalisation): self
  1329.     {
  1330.         if ($this->typeLocalisations->removeElement($typeLocalisation)) {
  1331.             $typeLocalisation->removeProduct($this);
  1332.         }
  1334.         return $this;
  1335.     }
  1337.     /**
  1338.      * @return Collection|Security[]
  1339.      */
  1340.     public function getSecurities(): Collection
  1341.     {
  1342.         return $this->securities;
  1343.     }
  1345.     public function addSecurity(Security $security): self
  1346.     {
  1347.         if (!$this->securities->contains($security)) {
  1348.             $this->securities[] = $security;
  1349.             $security->addProduct($this);
  1350.         }
  1352.         return $this;
  1353.     }
  1355.     public function removeSecurity(Security $security): self
  1356.     {
  1357.         if ($this->securities->removeElement($security)) {
  1358.             $security->removeProduct($this);
  1359.         }
  1361.         return $this;
  1362.     }
  1364.     public function getTaxeSejour(): ?float
  1365.     {
  1366.         return $this->taxeSejour;
  1367.     }
  1369.     public function setTaxeSejour(?float $taxeSejour): self
  1370.     {
  1371.         $this->taxeSejour = $taxeSejour;
  1373.         return $this;
  1374.     }
  1376.     public function getPrixCaution(): ?float
  1377.     {
  1378.         return $this->prixCaution;
  1379.     }
  1381.     public function setPrixCaution(?float $prixCaution): self
  1382.     {
  1383.         $this->prixCaution = $prixCaution;
  1385.         return $this;
  1386.     }
  1388.     public function getLongitude(): ?float
  1389.     {
  1390.         return $this->longitude;
  1391.     }
  1393.     public function setLongitude(?float $longitude): self
  1394.     {
  1395.         $this->longitude = $longitude;
  1397.         return $this;
  1398.     }
  1400.     public function getLatitude(): ?float
  1401.     {
  1402.         return $this->latitude;
  1403.     }
  1405.     public function setLatitude(?float $latitude): self
  1406.     {
  1407.         $this->latitude = $latitude;
  1409.         return $this;
  1410.     }
  1412.     public function getTypeActivity(): ?ActivityType
  1413.     {
  1414.         return $this->typeActivity;
  1415.     }
  1417.     public function setTypeActivity(?ActivityType $typeActivity): self
  1418.     {
  1419.         $this->typeActivity = $typeActivity;
  1421.         return $this;
  1422.     }
  1424.     /**
  1425.      * @return Collection<int, ProductReduction>
  1426.      */
  1427.     public function getProductReductions(): Collection
  1428.     {
  1429.         return $this->productReductions;
  1430.     }
  1432.     public function addProductReduction(ProductReduction $productReduction): self
  1433.     {
  1434.         if (!$this->productReductions->contains($productReduction)) {
  1435.             $this->productReductions[] = $productReduction;
  1436.             $productReduction->setProduct($this);
  1437.         }
  1439.         return $this;
  1440.     }
  1442.     public function removeProductReduction(ProductReduction $productReduction): self
  1443.     {
  1444.         if ($this->productReductions->removeElement($productReduction)) {
  1445.             // set the owning side to null (unless already changed)
  1446.             if ($productReduction->getProduct() === $this) {
  1447.                 $productReduction->setProduct(null);
  1448.             }
  1449.         }
  1451.         return $this;
  1452.     }
  1454.     public function getSpringPrice(): ?float
  1455.     {
  1456.         return $this->springPrice;
  1457.     }
  1459.     public function setSpringPrice(?float $springPrice): self
  1460.     {
  1461.         $this->springPrice = $springPrice;
  1463.         return $this;
  1464.     }
  1466.     public function getSummerPrice(): ?float
  1467.     {
  1468.         return $this->summerPrice;
  1469.     }
  1471.     public function setSummerPrice(?float $summerPrice): self
  1472.     {
  1473.         $this->summerPrice = $summerPrice;
  1475.         return $this;
  1476.     }
  1478.     public function getAutumnPrice(): ?float
  1479.     {
  1480.         return $this->autumnPrice;
  1481.     }
  1483.     public function setAutumnPrice(?float $autumnPrice): self
  1484.     {
  1485.         $this->autumnPrice = $autumnPrice;
  1487.         return $this;
  1488.     }
  1490.     public function getWinterPrice(): ?float
  1491.     {
  1492.         return $this->winterPrice;
  1493.     }
  1495.     public function setWinterPrice(?float $winterPrice): self
  1496.     {
  1497.         $this->winterPrice = $winterPrice;
  1499.         return $this;
  1500.     }
  1502.     public function getWeekEndPrice(): ?float
  1503.     {
  1504.         return $this->weekEndPrice;
  1505.     }
  1507.     public function setWeekEndPrice(?float $weekEndPrice): self
  1508.     {
  1509.         $this->weekEndPrice = $weekEndPrice;
  1511.         return $this;
  1512.     }
  1514.     /**
  1515.      * @return Collection<int, ProgrammingDayPrice>
  1516.      */
  1517.     public function getDayPrice(): Collection
  1518.     {
  1519.         return $this->dayPrice;
  1520.     }
  1522.     public function addDayPrice(ProgrammingDayPrice $dayPrice): self
  1523.     {
  1524.         if (!$this->dayPrice->contains($dayPrice)) {
  1525.             $this->dayPrice[] = $dayPrice;
  1526.             $dayPrice->setProduct($this);
  1527.         }
  1529.         return $this;
  1530.     }
  1532.     public function removeDayPrice(ProgrammingDayPrice $dayPrice): self
  1533.     {
  1534.         if ($this->dayPrice->removeElement($dayPrice)) {
  1535.             // set the owning side to null (unless already changed)
  1536.             if ($dayPrice->getProduct() === $this) {
  1537.                 $dayPrice->setProduct(null);
  1538.             }
  1539.         }
  1541.         return $this;
  1542.     }
  1544.     /**
  1545.      * @return Collection<int, ProductAgenda>
  1546.      */
  1547.     public function getProductAgendas(): Collection
  1548.     {
  1549.         return $this->productAgendas;
  1550.     }
  1552.     public function addProductAgenda(ProductAgenda $productAgenda): self
  1553.     {
  1554.         if (!$this->productAgendas->contains($productAgenda)) {
  1555.             $this->productAgendas[] = $productAgenda;
  1556.             $productAgenda->setProduct($this);
  1557.         }
  1558.     }
  1559.     public function removeProductAgenda(ProductAgenda $productAgenda): self
  1560.     {
  1561.         if ($this->productAgendas->removeElement($productAgenda)) {
  1562.             // set the owning side to null (unless already changed)
  1563.             if ($productAgenda->getProduct() === $this) {
  1564.                 $productAgenda->setProduct(null);
  1565.             }
  1566.         }
  1567.     }
  1569.     /**
  1570.      * @return Collection<int, ProductAutoReduction>
  1571.      */
  1572.     public function getProductAutoReduction(): Collection
  1573.     {
  1574.         return $this->productAutoReduction;
  1575.     }
  1577.     public function addProductAutoReduction(ProductAutoReduction $productAutoReduction): self
  1578.     {
  1579.         if (!$this->productAutoReduction->contains($productAutoReduction)) {
  1580.             $this->productAutoReduction[] = $productAutoReduction;
  1581.             $productAutoReduction->setProduct($this);
  1582.         }
  1584.         return $this;
  1585.     }
  1587.     public function removeProductAutoReduction(ProductAutoReduction $productAutoReduction): self
  1588.     {
  1589.         if ($this->productAutoReduction->removeElement($productAutoReduction)) {
  1590.             // set the owning side to null (unless already changed)
  1591.             if ($productAutoReduction->getProduct() === $this) {
  1592.                 $productAutoReduction->setProduct(null);
  1593.             }
  1594.         }
  1596.         return $this;
  1597.     }
  1599.     /**
  1600.      * @return Collection<int, Publication>
  1601.      */
  1602.     public function getPublications(): Collection
  1603.     {
  1604.         return $this->publications;
  1605.     }
  1607.     public function addPublication(Publication $publication): self
  1608.     {
  1609.         if (!$this->publications->contains($publication)) {
  1610.             $this->publications[] = $publication;
  1611.             $publication->setProductCompany($this);
  1612.         }
  1614.         return $this;
  1615.     }
  1617.     public function removePublication(Publication $publication): self
  1618.     {
  1619.         if ($this->publications->removeElement($publication)) {
  1620.             // set the owning side to null (unless already changed)
  1621.             if ($publication->getProductCompany() === $this) {
  1622.                 $publication->setProductCompany(null);
  1623.             }
  1624.         }
  1626.         return $this;
  1627.     }
  1629.     /**
  1630.      * @return Collection<int, PendingLocation>
  1631.      */
  1632.     public function getPendingLocations(): Collection
  1633.     {
  1634.         return $this->pendingLocations;
  1635.     }
  1637.     public function addPendingLocation(PendingLocation $pendingLocation): self
  1638.     {
  1639.         if (!$this->pendingLocations->contains($pendingLocation)) {
  1640.             $this->pendingLocations[] = $pendingLocation;
  1641.             $pendingLocation->setProduct($this);
  1642.         }
  1644.         return $this;
  1645.     }
  1647.     public function removePendingLocation(PendingLocation $pendingLocation): self
  1648.     {
  1649.         if ($this->pendingLocations->removeElement($pendingLocation)) {
  1650.             // set the owning side to null (unless already changed)
  1651.             if ($pendingLocation->getProduct() === $this) {
  1652.                 $pendingLocation->setProduct(null);
  1653.             }
  1654.         }
  1656.         return $this;
  1657.     }
  1659.     /**
  1660.      * @return Collection<int, PendingReservation>
  1661.      */
  1662.     public function getPendingReservations(): Collection
  1663.     {
  1664.         return $this->pendingReservations;
  1665.     }
  1667.     public function addPendingReservation(PendingReservation $pendingReservation): self
  1668.     {
  1669.         if (!$this->pendingReservations->contains($pendingReservation)) {
  1670.             $this->pendingReservations[] = $pendingReservation;
  1671.             $pendingReservation->setProduct($this);
  1672.         }
  1674.         return $this;
  1675.     }
  1677.     public function removePendingReservation(PendingReservation $pendingReservation): self
  1678.     {
  1679.         if ($this->pendingReservations->removeElement($pendingReservation)) {
  1680.             // set the owning side to null (unless already changed)
  1681.             if ($pendingReservation->getProduct() === $this) {
  1682.                 $pendingReservation->setProduct(null);
  1683.             }
  1684.         }
  1686.         return $this;
  1687.     }
  1689.     /**
  1690.      * @return Collection<int, ProductPeriodPrice>
  1691.      */
  1692.     public function getPeriodPrice(): Collection
  1693.     {
  1694.         return $this->periodPrice;
  1695.     }
  1697.     public function addPeriodPrice(ProductPeriodPrice $periodPrice): self
  1698.     {
  1699.         if (!$this->periodPrice->contains($periodPrice)) {
  1700.             $this->periodPrice[] = $periodPrice;
  1701.             $periodPrice->setProduct($this);
  1702.         }
  1704.         return $this;
  1705.     }
  1706.     public function removePeriodPrice(ProductPeriodPrice $periodPrice): self
  1707.     {
  1708.         if ($this->periodPrice->removeElement($periodPrice)) {
  1709.             // set the owning side to null (unless already changed)
  1710.             if ($periodPrice->getProduct() === $this) {
  1711.                 $periodPrice->setProduct(null);
  1712.             }
  1713.         }
  1715.         return $this;
  1716.     }
  1717.     public function getCityLocalisation(): ?string
  1718.     {
  1719.         return $this->cityLocalisation;
  1720.     }
  1722.     public function setCityLocalisation(?string $cityLocalisation): self
  1723.     {
  1724.         $this->cityLocalisation = $cityLocalisation;
  1726.         return $this;
  1727.     }
  1729.     public function getNbChambre(): ?int
  1730.     {
  1731.         return $this->nbChambre;
  1732.     }
  1734.     public function setNbChambre(?int $nbChambre): self
  1735.     {
  1736.         $this->nbChambre = $nbChambre;
  1738.         return $this;
  1739.     }
  1741.     public function getNightMin(): ?int
  1742.     {
  1743.         return $this->nightMin;
  1744.     }
  1746.     public function setNightMin(?int $nightMin): self
  1747.     {
  1748.         $this->nightMin = $nightMin;
  1750.         return $this;
  1751.     }
  1753.     /**
  1754.      * @return Collection<int, TarifDegressif>
  1755.      */
  1756.     public function getTarifDegressifs(): Collection
  1757.     {
  1758.         return $this->tarifDegressifs;
  1759.     }
  1761.     public function addTarifDegressif(TarifDegressif $tarifDegressif): self
  1762.     {
  1763.         if (!$this->tarifDegressifs->contains($tarifDegressif)) {
  1764.             $this->tarifDegressifs[] = $tarifDegressif;
  1765.             $tarifDegressif->setProduct($this);
  1766.         }
  1768.         return $this;
  1769.     }
  1771.     public function removeTarifDegressif(TarifDegressif $tarifDegressif): self
  1772.     {
  1773.         if ($this->tarifDegressifs->removeElement($tarifDegressif)) {
  1774.             // set the owning side to null (unless already changed)
  1775.             if ($tarifDegressif->getProduct() === $this) {
  1776.                 $tarifDegressif->setProduct(null);
  1777.             }
  1778.         }
  1780.         return $this;
  1781.     }
  1783.     /**
  1784.      * @return Collection<int, EquipementsCuisine>
  1785.      */
  1786.     public function getEquipementsCuisines(): Collection
  1787.     {
  1788.         return $this->equipementsCuisines;
  1789.     }
  1791.     public function addEquipementsCuisine(EquipementsCuisine $equipementsCuisine): self
  1792.     {
  1793.         if (!$this->equipementsCuisines->contains($equipementsCuisine)) {
  1794.             $this->equipementsCuisines[] = $equipementsCuisine;
  1795.             $equipementsCuisine->addProduct($this);
  1796.         }
  1798.         return $this;
  1799.     }
  1801.     public function removeEquipementsCuisine(EquipementsCuisine $equipementsCuisine): self
  1802.     {
  1803.         if ($this->equipementsCuisines->removeElement($equipementsCuisine)) {
  1804.             $equipementsCuisine->removeProduct($this);
  1805.         }
  1807.         return $this;
  1808.     }
  1810.     /**
  1811.      * @return Collection<int, SalleDeBain>
  1812.      */
  1813.     public function getSalleDeBains(): Collection
  1814.     {
  1815.         return $this->salleDeBains;
  1816.     }
  1818.     public function addSalleDeBain(SalleDeBain $salleDeBain): self
  1819.     {
  1820.         if (!$this->salleDeBains->contains($salleDeBain)) {
  1821.             $this->salleDeBains[] = $salleDeBain;
  1822.             $salleDeBain->addProduct($this);
  1823.         }
  1825.         return $this;
  1826.     }
  1828.     public function removeSalleDeBain(SalleDeBain $salleDeBain): self
  1829.     {
  1830.         if ($this->salleDeBains->removeElement($salleDeBain)) {
  1831.             $salleDeBain->removeProduct($this);
  1832.         }
  1834.         return $this;
  1835.     }
  1837.     /**
  1838.      * @return Collection<int, AccessoiresDeChambre>
  1839.      */
  1840.     public function getAccessoiresDeChambres(): Collection
  1841.     {
  1842.         return $this->accessoiresDeChambres;
  1843.     }
  1845.     public function addAccessoiresDeChambre(AccessoiresDeChambre $accessoiresDeChambre): self
  1846.     {
  1847.         if (!$this->accessoiresDeChambres->contains($accessoiresDeChambre)) {
  1848.             $this->accessoiresDeChambres[] = $accessoiresDeChambre;
  1849.             $accessoiresDeChambre->addProduct($this);
  1850.         }
  1852.         return $this;
  1853.     }
  1855.     public function removeAccessoiresDeChambre(AccessoiresDeChambre $accessoiresDeChambre): self
  1856.     {
  1857.         if ($this->accessoiresDeChambres->removeElement($accessoiresDeChambre)) {
  1858.             $accessoiresDeChambre->removeProduct($this);
  1859.         }
  1861.         return $this;
  1862.     }
  1864.     /**
  1865.      * @return Collection<int, MobilierExterieur>
  1866.      */
  1867.     public function getMobilierExterieurs(): Collection
  1868.     {
  1869.         return $this->mobilierExterieurs;
  1870.     }
  1872.     public function addMobilierExterieur(MobilierExterieur $mobilierExterieur): self
  1873.     {
  1874.         if (!$this->mobilierExterieurs->contains($mobilierExterieur)) {
  1875.             $this->mobilierExterieurs[] = $mobilierExterieur;
  1876.             $mobilierExterieur->addProduct($this);
  1877.         }
  1879.         return $this;
  1880.     }
  1882.     public function removeMobilierExterieur(MobilierExterieur $mobilierExterieur): self
  1883.     {
  1884.         if ($this->mobilierExterieurs->removeElement($mobilierExterieur)) {
  1885.             $mobilierExterieur->removeProduct($this);
  1886.         }
  1888.         return $this;
  1889.     }
  1891.     public function getCaracteristiqueVehicule(): ?CaracteristiqueVehicule
  1892.     {
  1893.         return $this->caracteristiqueVehicule;
  1894.     }
  1896.     public function setCaracteristiqueVehicule(?CaracteristiqueVehicule $caracteristiqueVehicule): self
  1897.     {
  1898.         $this->caracteristiqueVehicule = $caracteristiqueVehicule;
  1900.         return $this;
  1901.     }
  1903.     /**
  1904.      * @return Collection<int, Notification>
  1905.      */
  1906.     public function getNotificationReservation(): Collection
  1907.     {
  1908.         return $this->notificationReservation;
  1909.     }
  1911.     public function addNotificationReservation(Notification $notificationReservation): self
  1912.     {
  1913.         if (!$this->notificationReservation->contains($notificationReservation)) {
  1914.             $this->notificationReservation[] = $notificationReservation;
  1915.             $notificationReservation->setProduct($this);
  1916.         }
  1918.         return $this;
  1919.     }
  1921.     public function removeNotificationReservation(Notification $notificationReservation): self
  1922.     {
  1923.         if ($this->notificationReservation->removeElement($notificationReservation)) {
  1924.             // set the owning side to null (unless already changed)
  1925.             if ($notificationReservation->getProduct() === $this) {
  1926.                 $notificationReservation->setProduct(null);
  1927.             }
  1928.         }
  1930.         return $this;
  1931.     }
  1933.     public function getCommune(): ?Commune
  1934.     {
  1935.         return $this->commune;
  1936.     }
  1938.     public function setCommune(?Commune $commune): self
  1939.     {
  1940.         $this->commune = $commune;
  1942.         return $this;
  1943.     }
  1944. }