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.     /**
  414.      * @ORM\ManyToMany(targetEntity=LocalisatioHebergs::class, mappedBy="produit")
  415.      */
  416.     private $localisatioHebergs;
  418.     public function __construct()
  419.     {
  420.         $this->photos = new ArrayCollection();
  421.         $this->departments = new ArrayCollection();
  422.         $this->commandProducts = new ArrayCollection();
  423.         $this->avis = new ArrayCollection();
  424.         $this->isActivated = true;
  425.         $this->isDesactivatedByAdmin = false;
  426.         $this->productPercents = new ArrayCollection();
  427.         $this->contactProducts = new ArrayCollection();
  428.         $this->productOptions = new ArrayCollection();
  429.         $this->subCategories = new ArrayCollection();
  430.         $this->annonceCompanies = new ArrayCollection();
  431.         $this->locations = new ArrayCollection();
  432.         $this->reservations = new ArrayCollection();
  433.         $this->cautions = new ArrayCollection();
  434.         $this->participants = new ArrayCollection();
  435.         $this->chambres = new ArrayCollection();
  436.         $this->caracteristics = new ArrayCollection();
  437.         $this->equipment = new ArrayCollection();
  438.         $this->langueHotes = new ArrayCollection();
  439.         $this->typeLocalisations = new ArrayCollection();
  440.         $this->securities = new ArrayCollection();
  441.         $this->productReductions = new ArrayCollection();
  442.         $this->dayPrice = new ArrayCollection();
  443.         $this->productAgendas = new ArrayCollection();
  444.         $this->productAutoReduction = new ArrayCollection();
  445.         $this->publications = new ArrayCollection();
  446.         $this->pendingLocations = new ArrayCollection();
  447.         $this->pendingReservations = new ArrayCollection();
  448.         $this->periodPrice = new ArrayCollection();
  449.         $this->tarifDegressifs = new ArrayCollection();
  450.         $this->equipementsCuisines = new ArrayCollection();
  451.         $this->salleDeBains = new ArrayCollection();
  452.         $this->accessoiresDeChambres = new ArrayCollection();
  453.         $this->mobilierExterieurs = new ArrayCollection();
  454.         $this->notificationReservation = new ArrayCollection();
  455.         $this->localisatioHebergs = new ArrayCollection();
  456.     }
  458.     public function getId(): ?int
  459.     {
  460.         return $this->id;
  461.     }
  463.     public function getPercentDeposit(): ?int
  464.     {
  465.         return $this->percentDeposit;
  466.     }
  468.     public function setPercentDeposit(?int $percentDeposit): self
  469.     {
  470.         $this->percentDeposit = $percentDeposit;
  472.         return $this;
  473.     }
  475.     public function getDeadline(): ?int
  476.     {
  477.         return $this->deadline;
  478.     }
  480.     public function setDeadline(?int $deadline): self
  481.     {
  482.         $this->deadline = $deadline;
  484.         return $this;
  485.     }
  487.     public function getName(): ?string
  488.     {
  489.         return $this->name;
  490.     }
  492.     public function setName(?string $name): self
  493.     {
  494.         $this->name = $name;
  496.         return $this;
  497.     }
  499.     public function getText(): ?string
  500.     {
  501.         return $this->text;
  502.     }
  504.     public function setText(?string $text): self
  505.     {
  506.         $this->text = $text;
  508.         return $this;
  509.     }
  511.     public function getPrice(): ?float
  512.     {
  513.         return $this->price;
  514.     }
  516.     public function setPrice(float $price): self
  517.     {
  518.         $this->price = $price;
  520.         return $this;
  521.     }
  523.     public function getQuantity(): ?int
  524.     {
  525.         return $this->quantity;
  526.     }
  528.     public function setQuantity(?int $quantity): self
  529.     {
  530.         $this->quantity = $quantity;
  532.         return $this;
  533.     }
  535.     /**
  536.      * @return Collection|Photos[]
  537.      */
  538.     public function getPhotos(): Collection
  539.     {
  540.         return $this->photos;
  541.     }
  543.     public function addPhoto(Photos $photo): self
  544.     {
  545.         if (!$this->photos->contains($photo)) {
  546.             $this->photos[] = $photo;
  547.             $photo->setProduct($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removePhoto(Photos $photo): self
  554.     {
  555.         if ($this->photos->contains($photo)) {
  556.             $this->photos->removeElement($photo);
  557.             // set the owning side to null (unless already changed)
  558.             if ($photo->getProduct() === $this) {
  559.                 $photo->setProduct(null);
  560.             }
  561.         }
  563.         return $this;
  564.     }
  566.     public function getCompany(): ?Company
  567.     {
  568.         return $this->company;
  569.     }
  571.     public function setCompany(?Company $company): self
  572.     {
  573.         $this->company = $company;
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return mixed
  580.      */
  581.     public function getProductSlug()
  582.     {
  583.         return $this->productSlug;
  584.     }
  586.     /**
  587.      * @param mixed $productSlug
  588.      */
  589.     public function setProductSlug($productSlug): void
  590.     {
  591.         $this->productSlug = $productSlug;
  592.     }
  594.     /**
  595.      * @return Collection|Department[]
  596.      */
  597.     public function getDepartments(): Collection
  598.     {
  599.         return $this->departments;
  600.     }
  602.     public function addDepartment(Department $department): self
  603.     {
  604.         if (!$this->departments->contains($department)) {
  605.             $this->departments[] = $department;
  606.         }
  608.         return $this;
  609.     }
  611.     public function removeDepartment(Department $department): self
  612.     {
  613.         if ($this->departments->contains($department)) {
  614.             $this->departments->removeElement($department);
  615.         }
  617.         return $this;
  618.     }
  620.     public function getSizes(): ?array
  621.     {
  622.         return $this->sizes;
  623.     }
  625.     public function setSizes(?array $sizes): self
  626.     {
  627.         $this->sizes = $sizes;
  629.         return $this;
  630.     }
  632.     /**
  633.      * @return Collection|CommandProduct[]
  634.      */
  635.     public function getCommandProducts(): Collection
  636.     {
  637.         return $this->commandProducts;
  638.     }
  640.     public function addCommandProduct(CommandProduct $commandProduct): self
  641.     {
  642.         if (!$this->commandProducts->contains($commandProduct)) {
  643.             $this->commandProducts[] = $commandProduct;
  644.             $commandProduct->setProduct($this);
  645.         }
  647.         return $this;
  648.     }
  650.     public function removeCommandProduct(CommandProduct $commandProduct): self
  651.     {
  652.         if ($this->commandProducts->contains($commandProduct)) {
  653.             $this->commandProducts->removeElement($commandProduct);
  654.             // set the owning side to null (unless already changed)
  655.             if ($commandProduct->getProduct() === $this) {
  656.                 $commandProduct->setProduct(null);
  657.             }
  658.         }
  660.         return $this;
  661.     }
  663.     /**
  664.      * @return Collection|Avis[]
  665.      */
  666.     public function getAvis(): Collection
  667.     {
  668.         return $this->avis;
  669.     }
  671.     public function addAvi(Avis $avi): self
  672.     {
  673.         if (!$this->avis->contains($avi)) {
  674.             $this->avis[] = $avi;
  675.             $avi->setProduct($this);
  676.         }
  678.         return $this;
  679.     }
  681.     public function removeAvi(Avis $avi): self
  682.     {
  683.         if ($this->avis->contains($avi)) {
  684.             $this->avis->removeElement($avi);
  685.             // set the owning side to null (unless already changed)
  686.             if ($avi->getProduct() === $this) {
  687.                 $avi->setProduct(null);
  688.             }
  689.         }
  691.         return $this;
  692.     }
  694.     public function getPack(): ?Pack
  695.     {
  696.         return $this->pack;
  697.     }
  699.     public function setPack(?Pack $pack): self
  700.     {
  701.         $this->pack = $pack;
  703.         return $this;
  704.     }
  706.     public function getNbGuest(): ?int
  707.     {
  708.         return $this->nbGuest;
  709.     }
  711.     public function setNbGuest(?int $nbGuest): self
  712.     {
  713.         $this->nbGuest = $nbGuest;
  715.         return $this;
  716.     }
  718.     public function getYoutubeVideo(): ?string
  719.     {
  720.         return $this->youtubeVideo;
  721.     }
  723.     public function setYoutubeVideo(?string $youtubeVideo): self
  724.     {
  725.         $this->youtubeVideo = $youtubeVideo;
  727.         return $this;
  728.     }
  730.     public function getIsActivated(): ?bool
  731.     {
  732.         return $this->isActivated;
  733.     }
  735.     public function setIsActivated(bool $isActivated): self
  736.     {
  737.         $this->isActivated = $isActivated;
  739.         return $this;
  740.     }
  742.     /**
  743.      * @return false
  744.      */
  745.     public function getIsDesactivatedByAdmin(): bool
  746.     {
  747.         return $this->isDesactivatedByAdmin;
  748.     }
  750.     /**
  751.      * @param false $isDesactivatedByAdmin
  752.      * @return Product
  753.      */
  754.     public function setIsDesactivatedByAdmin(bool $isDesactivatedByAdmin): Product
  755.     {
  756.         $this->isDesactivatedByAdmin = $isDesactivatedByAdmin;
  757.         return $this;
  758.     }
  760.     public function getModeLivraison(): ?array
  761.     {
  762.         return $this->modeLivraison;
  763.     }
  765.     public function setModeLivraison(?array $modeLivraison): self
  766.     {
  767.         $this->modeLivraison = $modeLivraison;
  769.         return $this;
  770.     }
  772.     public function getFraisLivraison(): ?float
  773.     {
  774.         return $this->fraisLivraison;
  775.     }
  777.     public function setFraisLivraison(?float $fraisLivraison): self
  778.     {
  779.         $this->fraisLivraison = $fraisLivraison;
  781.         return $this;
  782.     }
  784.     public function getColors(): ?array
  785.     {
  786.         return $this->colors;
  787.     }
  789.     public function setColors(?array $colors): self
  790.     {
  791.         $this->colors = $colors;
  793.         return $this;
  794.     }
  796.     /**
  797.      * @return Collection|ProductPercent[]
  798.      */
  799.     public function getProductPercents(): Collection
  800.     {
  801.         return $this->productPercents;
  802.     }
  804.     public function addProductPercent(ProductPercent $productPercent): self
  805.     {
  806.         if (!$this->productPercents->contains($productPercent)) {
  807.             $this->productPercents[] = $productPercent;
  808.             $productPercent->setProduct($this);
  809.         }
  811.         return $this;
  812.     }
  814.     public function removeProductPercent(ProductPercent $productPercent): self
  815.     {
  816.         if ($this->productPercents->contains($productPercent)) {
  817.             $this->productPercents->removeElement($productPercent);
  818.             // set the owning side to null (unless already changed)
  819.             if ($productPercent->getProduct() === $this) {
  820.                 $productPercent->setProduct(null);
  821.             }
  822.         }
  824.         return $this;
  825.     }
  827.     public function getProductNamePrice()
  828.     {
  829.         return $this->name . ' - ' . $this->price . '€ - ' . $this->getCompany()->getCompanyName();
  830.     }
  832.     public function getSizeRing(): ?array
  833.     {
  834.         return $this->sizeRing;
  835.     }
  837.     public function setSizeRing(?array $sizeRing): self
  838.     {
  839.         $this->sizeRing = $sizeRing;
  841.         return $this;
  842.     }
  844.     /**
  845.      * @return Collection|ContactProduct[]
  846.      */
  847.     public function getContactProducts(): Collection
  848.     {
  849.         return $this->contactProducts;
  850.     }
  852.     public function addContactProduct(ContactProduct $contactProduct): self
  853.     {
  854.         if (!$this->contactProducts->contains($contactProduct)) {
  855.             $this->contactProducts[] = $contactProduct;
  856.             $contactProduct->setProduct($this);
  857.         }
  859.         return $this;
  860.     }
  862.     public function removeContactProduct(ContactProduct $contactProduct): self
  863.     {
  864.         if ($this->contactProducts->contains($contactProduct)) {
  865.             $this->contactProducts->removeElement($contactProduct);
  866.             // set the owning side to null (unless already changed)
  867.             if ($contactProduct->getProduct() === $this) {
  868.                 $contactProduct->setProduct(null);
  869.             }
  870.         }
  872.         return $this;
  873.     }
  875.     /**
  876.      * @return Collection|ProductOption[]
  877.      */
  878.     public function getProductOptions(): Collection
  879.     {
  880.         return $this->productOptions;
  881.     }
  883.     public function addProductOption(ProductOption $productOption): self
  884.     {
  885.         if (!$this->productOptions->contains($productOption)) {
  886.             $this->productOptions[] = $productOption;
  887.             $productOption->setProduct($this);
  888.         }
  890.         return $this;
  891.     }
  893.     public function removeProductOption(ProductOption $productOption): self
  894.     {
  895.         if ($this->productOptions->removeElement($productOption)) {
  896.             // set the owning side to null (unless already changed)
  897.             if ($productOption->getProduct() === $this) {
  898.                 $productOption->setProduct(null);
  899.             }
  900.         }
  902.         return $this;
  903.     }
  905.     /**
  906.      * @return Collection|SubCategory[]
  907.      */
  908.     public function getSubCategories(): Collection
  909.     {
  910.         return $this->subCategories;
  911.     }
  913.     public function addSubCategory(SubCategory $subCategory): self
  914.     {
  915.         if (!$this->subCategories->contains($subCategory)) {
  916.             $this->subCategories[] = $subCategory;
  917.         }
  919.         return $this;
  920.     }
  922.     public function removeSubCategory(SubCategory $subCategory): self
  923.     {
  924.         $this->subCategories->removeElement($subCategory);
  926.         return $this;
  927.     }
  929.     public function getWeight(): ?string
  930.     {
  931.         return $this->weight;
  932.     }
  934.     public function setWeight(?string $weight): self
  935.     {
  936.         $this->weight = $weight;
  938.         return $this;
  939.     }
  941.     public function getTransporteurs(): ?array
  942.     {
  943.         return $this->transporteurs;
  944.     }
  946.     public function setTransporteurs(?array $transporteurs): self
  947.     {
  948.         $this->transporteurs = $transporteurs;
  950.         return $this;
  951.     }
  953.     public function getCodePromo(): ?string
  954.     {
  955.         return $this->codePromo;
  956.     }
  958.     public function setCodePromo(?string $codePromo): self
  959.     {
  960.         $this->codePromo = $codePromo;
  962.         return $this;
  963.     }
  965.     public function getCodePromoEuro(): ?float
  966.     {
  967.         return $this->codePromoEuro;
  968.     }
  970.     public function setCodePromoEuro(?float $codePromoEuro): self
  971.     {
  972.         $this->codePromoEuro = $codePromoEuro;
  974.         return $this;
  975.     }
  977.     public function getProductDescription(): ?ProductDescription
  978.     {
  979.         return $this->productDescription;
  980.     }
  982.     public function setProductDescription(?ProductDescription $productDescription): self
  983.     {
  984.         // unset the owning side of the relation if necessary
  985.         if ($productDescription === null && $this->productDescription !== null) {
  986.             $this->productDescription->setProduct(null);
  987.         }
  989.         // set the owning side of the relation if necessary
  990.         if ($productDescription !== null && $productDescription->getProduct() !== $this) {
  991.             $productDescription->setProduct($this);
  992.         }
  994.         $this->productDescription = $productDescription;
  996.         return $this;
  997.     }
  999.     public function getTemplate(): ?int
  1000.     {
  1001.         return $this->template;
  1002.     }
  1004.     public function setTemplate(?int $template): self
  1005.     {
  1006.         $this->template = $template;
  1008.         return $this;
  1009.     }
  1011.     /**
  1012.      * @return Collection|AnnonceCompany[]
  1013.      */
  1014.     public function getAnnonceCompanies(): Collection
  1015.     {
  1016.         return $this->annonceCompanies;
  1017.     }
  1019.     public function addAnnonceCompany(AnnonceCompany $annonceCompany): self
  1020.     {
  1021.         if (!$this->annonceCompanies->contains($annonceCompany)) {
  1022.             $this->annonceCompanies[] = $annonceCompany;
  1023.             $annonceCompany->setProducts($this);
  1024.         }
  1026.         return $this;
  1027.     }
  1029.     public function removeAnnonceCompany(AnnonceCompany $annonceCompany): self
  1030.     {
  1031.         if ($this->annonceCompanies->removeElement($annonceCompany)) {
  1032.             // set the owning side to null (unless already changed)
  1033.             if ($annonceCompany->getProducts() === $this) {
  1034.                 $annonceCompany->setProducts(null);
  1035.             }
  1036.         }
  1038.         return $this;
  1039.     }
  1041.     public function getTypeLocation(): ?TypeLocation
  1042.     {
  1043.         return $this->typeLocation;
  1044.     }
  1046.     public function setTypeLocation(?TypeLocation $typeLocation): self
  1047.     {
  1048.         $this->typeLocation = $typeLocation;
  1050.         return $this;
  1051.     }
  1053.     public function getTypePrestation(): ?TypePrestation
  1054.     {
  1055.         return $this->typePrestation;
  1056.     }
  1058.     public function setTypePrestation(?TypePrestation $typePrestation): self
  1059.     {
  1060.         $this->typePrestation = $typePrestation;
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * @return Collection|Location[]
  1067.      */
  1068.     public function getLocations(): Collection
  1069.     {
  1070.         return $this->locations;
  1071.     }
  1073.     public function addLocation(Location $location): self
  1074.     {
  1075.         if (!$this->locations->contains($location)) {
  1076.             $this->locations[] = $location;
  1077.             $location->setProduct($this);
  1078.         }
  1080.         return $this;
  1081.     }
  1083.     public function removeLocation(Location $location): self
  1084.     {
  1085.         if ($this->locations->removeElement($location)) {
  1086.             // set the owning side to null (unless already changed)
  1087.             if ($location->getProduct() === $this) {
  1088.                 $location->setProduct(null);
  1089.             }
  1090.         }
  1092.         return $this;
  1093.     }
  1095.     /**
  1096.      * @return Collection|Reservation[]
  1097.      */
  1098.     public function getReservations(): Collection
  1099.     {
  1100.         return $this->reservations;
  1101.     }
  1103.     public function addReservation(Reservation $reservation): self
  1104.     {
  1105.         if (!$this->reservations->contains($reservation)) {
  1106.             $this->reservations[] = $reservation;
  1107.             $reservation->setProduct($this);
  1108.         }
  1110.         return $this;
  1111.     }
  1113.     public function removeReservation(Reservation $reservation): self
  1114.     {
  1115.         if ($this->reservations->removeElement($reservation)) {
  1116.             // set the owning side to null (unless already changed)
  1117.             if ($reservation->getProduct() === $this) {
  1118.                 $reservation->setProduct(null);
  1119.             }
  1120.         }
  1122.         return $this;
  1123.     }
  1126.     public function getTva(): ?Tva
  1127.     {
  1128.         return $this->tva;
  1129.     }
  1131.     public function setTva(?Tva $tva): self
  1132.     {
  1133.         $this->tva = $tva;
  1135.         return $this;
  1136.     }
  1138.     /**
  1139.      * @return Collection|Caution[]
  1140.      */
  1141.     public function getCautions(): Collection
  1142.     {
  1143.         return $this->cautions;
  1144.     }
  1146.     public function addCaution(Caution $caution): self
  1147.     {
  1148.         if (!$this->cautions->contains($caution)) {
  1149.             $this->cautions[] = $caution;
  1150.             $caution->setProduct($this);
  1151.         }
  1153.         return $this;
  1154.     }
  1156.     public function removeCaution(Caution $caution): self
  1157.     {
  1158.         if ($this->cautions->removeElement($caution)) {
  1159.             // set the owning side to null (unless already changed)
  1160.             if ($caution->getProduct() === $this) {
  1161.                 $caution->setProduct(null);
  1162.             }
  1163.         }
  1165.         return $this;
  1166.     }
  1168.     /**
  1169.      * @return Collection|Participant[]
  1170.      */
  1171.     public function getParticipants(): Collection
  1172.     {
  1173.         return $this->participants;
  1174.     }
  1176.     public function addParticipant(Participant $participant): self
  1177.     {
  1178.         if (!$this->participants->contains($participant)) {
  1179.             $this->participants[] = $participant;
  1180.             $participant->setProduit($this);
  1181.         }
  1183.         return $this;
  1184.     }
  1186.     public function removeParticipant(Participant $participant): self
  1187.     {
  1188.         if ($this->participants->removeElement($participant)) {
  1189.             // set the owning side to null (unless already changed)
  1190.             if ($participant->getProduit() === $this) {
  1191.                 $participant->setProduit(null);
  1192.             }
  1193.         }
  1195.         return $this;
  1196.     }
  1198.     public function getTypeHebergements(): ?TypeHebergement
  1199.     {
  1200.         return $this->typeHebergements;
  1201.     }
  1203.     public function setTypeHebergements(?TypeHebergement $typeHebergements): self
  1204.     {
  1205.         $this->typeHebergements = $typeHebergements;
  1207.         return $this;
  1208.     }
  1210.     /**
  1211.      * @return Collection|Chambre[]
  1212.      */
  1213.     public function getChambres(): Collection
  1214.     {
  1215.         return $this->chambres;
  1216.     }
  1218.     public function addChambre(Chambre $chambre): self
  1219.     {
  1220.         if (!$this->chambres->contains($chambre)) {
  1221.             $this->chambres[] = $chambre;
  1222.             $chambre->setProduct($this);
  1223.         }
  1225.         return $this;
  1226.     }
  1228.     public function removeChambre(Chambre $chambre): self
  1229.     {
  1230.         $this->chambres->removeElement($chambre);
  1232.         return $this;
  1233.     }
  1235.     /**
  1236.      * @return Collection|Caracteristic[]
  1237.      */
  1238.     public function getCaracteristics(): Collection
  1239.     {
  1240.         return $this->caracteristics;
  1241.     }
  1243.     public function addCaracteristic(Caracteristic $caracteristic): self
  1244.     {
  1245.         if (!$this->caracteristics->contains($caracteristic)) {
  1246.             $this->caracteristics[] = $caracteristic;
  1247.             $caracteristic->addProduct($this);
  1248.         }
  1250.         return $this;
  1251.     }
  1253.     public function removeCaracteristic(Caracteristic $caracteristic): self
  1254.     {
  1255.         if ($this->caracteristics->removeElement($caracteristic)) {
  1256.             $caracteristic->removeProduct($this);
  1257.         }
  1259.         return $this;
  1260.     }
  1262.     /**
  1263.      * @return Collection|Equipment[]
  1264.      */
  1265.     public function getEquipment(): Collection
  1266.     {
  1267.         return $this->equipment;
  1268.     }
  1270.     public function addEquipment(Equipment $equipment): self
  1271.     {
  1272.         if (!$this->equipment->contains($equipment)) {
  1273.             $this->equipment[] = $equipment;
  1274.             $equipment->addProduct($this);
  1275.         }
  1277.         return $this;
  1278.     }
  1280.     public function removeEquipment(Equipment $equipment): self
  1281.     {
  1282.         if ($this->equipment->removeElement($equipment)) {
  1283.             $equipment->removeProduct($this);
  1284.         }
  1286.         return $this;
  1287.     }
  1289.     /**
  1290.      * @return Collection|LangueHote[]
  1291.      */
  1292.     public function getLangueHotes(): Collection
  1293.     {
  1294.         return $this->langueHotes;
  1295.     }
  1297.     public function addLangueHote(LangueHote $langueHote): self
  1298.     {
  1299.         if (!$this->langueHotes->contains($langueHote)) {
  1300.             $this->langueHotes[] = $langueHote;
  1301.             $langueHote->addProduct($this);
  1302.         }
  1304.         return $this;
  1305.     }
  1307.     public function removeLangueHote(LangueHote $langueHote): self
  1308.     {
  1309.         if ($this->langueHotes->removeElement($langueHote)) {
  1310.             $langueHote->removeProduct($this);
  1311.         }
  1313.         return $this;
  1314.     }
  1316.     /**
  1317.      * @return Collection|TypeLocalisation[]
  1318.      */
  1319.     public function getTypeLocalisations(): Collection
  1320.     {
  1321.         return $this->typeLocalisations;
  1322.     }
  1324.     public function addTypeLocalisation(TypeLocalisation $typeLocalisation): self
  1325.     {
  1326.         if (!$this->typeLocalisations->contains($typeLocalisation)) {
  1327.             $this->typeLocalisations[] = $typeLocalisation;
  1328.             $typeLocalisation->addProduct($this);
  1329.         }
  1331.         return $this;
  1332.     }
  1334.     public function removeTypeLocalisation(TypeLocalisation $typeLocalisation): self
  1335.     {
  1336.         if ($this->typeLocalisations->removeElement($typeLocalisation)) {
  1337.             $typeLocalisation->removeProduct($this);
  1338.         }
  1340.         return $this;
  1341.     }
  1343.     /**
  1344.      * @return Collection|Security[]
  1345.      */
  1346.     public function getSecurities(): Collection
  1347.     {
  1348.         return $this->securities;
  1349.     }
  1351.     public function addSecurity(Security $security): self
  1352.     {
  1353.         if (!$this->securities->contains($security)) {
  1354.             $this->securities[] = $security;
  1355.             $security->addProduct($this);
  1356.         }
  1358.         return $this;
  1359.     }
  1361.     public function removeSecurity(Security $security): self
  1362.     {
  1363.         if ($this->securities->removeElement($security)) {
  1364.             $security->removeProduct($this);
  1365.         }
  1367.         return $this;
  1368.     }
  1370.     public function getTaxeSejour(): ?float
  1371.     {
  1372.         return $this->taxeSejour;
  1373.     }
  1375.     public function setTaxeSejour(?float $taxeSejour): self
  1376.     {
  1377.         $this->taxeSejour = $taxeSejour;
  1379.         return $this;
  1380.     }
  1382.     public function getPrixCaution(): ?float
  1383.     {
  1384.         return $this->prixCaution;
  1385.     }
  1387.     public function setPrixCaution(?float $prixCaution): self
  1388.     {
  1389.         $this->prixCaution = $prixCaution;
  1391.         return $this;
  1392.     }
  1394.     public function getLongitude(): ?float
  1395.     {
  1396.         return $this->longitude;
  1397.     }
  1399.     public function setLongitude(?float $longitude): self
  1400.     {
  1401.         $this->longitude = $longitude;
  1403.         return $this;
  1404.     }
  1406.     public function getLatitude(): ?float
  1407.     {
  1408.         return $this->latitude;
  1409.     }
  1411.     public function setLatitude(?float $latitude): self
  1412.     {
  1413.         $this->latitude = $latitude;
  1415.         return $this;
  1416.     }
  1418.     public function getTypeActivity(): ?ActivityType
  1419.     {
  1420.         return $this->typeActivity;
  1421.     }
  1423.     public function setTypeActivity(?ActivityType $typeActivity): self
  1424.     {
  1425.         $this->typeActivity = $typeActivity;
  1427.         return $this;
  1428.     }
  1430.     /**
  1431.      * @return Collection<int, ProductReduction>
  1432.      */
  1433.     public function getProductReductions(): Collection
  1434.     {
  1435.         return $this->productReductions;
  1436.     }
  1438.     public function addProductReduction(ProductReduction $productReduction): self
  1439.     {
  1440.         if (!$this->productReductions->contains($productReduction)) {
  1441.             $this->productReductions[] = $productReduction;
  1442.             $productReduction->setProduct($this);
  1443.         }
  1445.         return $this;
  1446.     }
  1448.     public function removeProductReduction(ProductReduction $productReduction): self
  1449.     {
  1450.         if ($this->productReductions->removeElement($productReduction)) {
  1451.             // set the owning side to null (unless already changed)
  1452.             if ($productReduction->getProduct() === $this) {
  1453.                 $productReduction->setProduct(null);
  1454.             }
  1455.         }
  1457.         return $this;
  1458.     }
  1460.     public function getSpringPrice(): ?float
  1461.     {
  1462.         return $this->springPrice;
  1463.     }
  1465.     public function setSpringPrice(?float $springPrice): self
  1466.     {
  1467.         $this->springPrice = $springPrice;
  1469.         return $this;
  1470.     }
  1472.     public function getSummerPrice(): ?float
  1473.     {
  1474.         return $this->summerPrice;
  1475.     }
  1477.     public function setSummerPrice(?float $summerPrice): self
  1478.     {
  1479.         $this->summerPrice = $summerPrice;
  1481.         return $this;
  1482.     }
  1484.     public function getAutumnPrice(): ?float
  1485.     {
  1486.         return $this->autumnPrice;
  1487.     }
  1489.     public function setAutumnPrice(?float $autumnPrice): self
  1490.     {
  1491.         $this->autumnPrice = $autumnPrice;
  1493.         return $this;
  1494.     }
  1496.     public function getWinterPrice(): ?float
  1497.     {
  1498.         return $this->winterPrice;
  1499.     }
  1501.     public function setWinterPrice(?float $winterPrice): self
  1502.     {
  1503.         $this->winterPrice = $winterPrice;
  1505.         return $this;
  1506.     }
  1508.     public function getWeekEndPrice(): ?float
  1509.     {
  1510.         return $this->weekEndPrice;
  1511.     }
  1513.     public function setWeekEndPrice(?float $weekEndPrice): self
  1514.     {
  1515.         $this->weekEndPrice = $weekEndPrice;
  1517.         return $this;
  1518.     }
  1520.     /**
  1521.      * @return Collection<int, ProgrammingDayPrice>
  1522.      */
  1523.     public function getDayPrice(): Collection
  1524.     {
  1525.         return $this->dayPrice;
  1526.     }
  1528.     public function addDayPrice(ProgrammingDayPrice $dayPrice): self
  1529.     {
  1530.         if (!$this->dayPrice->contains($dayPrice)) {
  1531.             $this->dayPrice[] = $dayPrice;
  1532.             $dayPrice->setProduct($this);
  1533.         }
  1535.         return $this;
  1536.     }
  1538.     public function removeDayPrice(ProgrammingDayPrice $dayPrice): self
  1539.     {
  1540.         if ($this->dayPrice->removeElement($dayPrice)) {
  1541.             // set the owning side to null (unless already changed)
  1542.             if ($dayPrice->getProduct() === $this) {
  1543.                 $dayPrice->setProduct(null);
  1544.             }
  1545.         }
  1547.         return $this;
  1548.     }
  1550.     /**
  1551.      * @return Collection<int, ProductAgenda>
  1552.      */
  1553.     public function getProductAgendas(): Collection
  1554.     {
  1555.         return $this->productAgendas;
  1556.     }
  1558.     public function addProductAgenda(ProductAgenda $productAgenda): self
  1559.     {
  1560.         if (!$this->productAgendas->contains($productAgenda)) {
  1561.             $this->productAgendas[] = $productAgenda;
  1562.             $productAgenda->setProduct($this);
  1563.         }
  1564.     }
  1565.     public function removeProductAgenda(ProductAgenda $productAgenda): self
  1566.     {
  1567.         if ($this->productAgendas->removeElement($productAgenda)) {
  1568.             // set the owning side to null (unless already changed)
  1569.             if ($productAgenda->getProduct() === $this) {
  1570.                 $productAgenda->setProduct(null);
  1571.             }
  1572.         }
  1573.     }
  1575.     /**
  1576.      * @return Collection<int, ProductAutoReduction>
  1577.      */
  1578.     public function getProductAutoReduction(): Collection
  1579.     {
  1580.         return $this->productAutoReduction;
  1581.     }
  1583.     public function addProductAutoReduction(ProductAutoReduction $productAutoReduction): self
  1584.     {
  1585.         if (!$this->productAutoReduction->contains($productAutoReduction)) {
  1586.             $this->productAutoReduction[] = $productAutoReduction;
  1587.             $productAutoReduction->setProduct($this);
  1588.         }
  1590.         return $this;
  1591.     }
  1593.     public function removeProductAutoReduction(ProductAutoReduction $productAutoReduction): self
  1594.     {
  1595.         if ($this->productAutoReduction->removeElement($productAutoReduction)) {
  1596.             // set the owning side to null (unless already changed)
  1597.             if ($productAutoReduction->getProduct() === $this) {
  1598.                 $productAutoReduction->setProduct(null);
  1599.             }
  1600.         }
  1602.         return $this;
  1603.     }
  1605.     /**
  1606.      * @return Collection<int, Publication>
  1607.      */
  1608.     public function getPublications(): Collection
  1609.     {
  1610.         return $this->publications;
  1611.     }
  1613.     public function addPublication(Publication $publication): self
  1614.     {
  1615.         if (!$this->publications->contains($publication)) {
  1616.             $this->publications[] = $publication;
  1617.             $publication->setProductCompany($this);
  1618.         }
  1620.         return $this;
  1621.     }
  1623.     public function removePublication(Publication $publication): self
  1624.     {
  1625.         if ($this->publications->removeElement($publication)) {
  1626.             // set the owning side to null (unless already changed)
  1627.             if ($publication->getProductCompany() === $this) {
  1628.                 $publication->setProductCompany(null);
  1629.             }
  1630.         }
  1632.         return $this;
  1633.     }
  1635.     /**
  1636.      * @return Collection<int, PendingLocation>
  1637.      */
  1638.     public function getPendingLocations(): Collection
  1639.     {
  1640.         return $this->pendingLocations;
  1641.     }
  1643.     public function addPendingLocation(PendingLocation $pendingLocation): self
  1644.     {
  1645.         if (!$this->pendingLocations->contains($pendingLocation)) {
  1646.             $this->pendingLocations[] = $pendingLocation;
  1647.             $pendingLocation->setProduct($this);
  1648.         }
  1650.         return $this;
  1651.     }
  1653.     public function removePendingLocation(PendingLocation $pendingLocation): self
  1654.     {
  1655.         if ($this->pendingLocations->removeElement($pendingLocation)) {
  1656.             // set the owning side to null (unless already changed)
  1657.             if ($pendingLocation->getProduct() === $this) {
  1658.                 $pendingLocation->setProduct(null);
  1659.             }
  1660.         }
  1662.         return $this;
  1663.     }
  1665.     /**
  1666.      * @return Collection<int, PendingReservation>
  1667.      */
  1668.     public function getPendingReservations(): Collection
  1669.     {
  1670.         return $this->pendingReservations;
  1671.     }
  1673.     public function addPendingReservation(PendingReservation $pendingReservation): self
  1674.     {
  1675.         if (!$this->pendingReservations->contains($pendingReservation)) {
  1676.             $this->pendingReservations[] = $pendingReservation;
  1677.             $pendingReservation->setProduct($this);
  1678.         }
  1680.         return $this;
  1681.     }
  1683.     public function removePendingReservation(PendingReservation $pendingReservation): self
  1684.     {
  1685.         if ($this->pendingReservations->removeElement($pendingReservation)) {
  1686.             // set the owning side to null (unless already changed)
  1687.             if ($pendingReservation->getProduct() === $this) {
  1688.                 $pendingReservation->setProduct(null);
  1689.             }
  1690.         }
  1692.         return $this;
  1693.     }
  1695.     /**
  1696.      * @return Collection<int, ProductPeriodPrice>
  1697.      */
  1698.     public function getPeriodPrice(): Collection
  1699.     {
  1700.         return $this->periodPrice;
  1701.     }
  1703.     public function addPeriodPrice(ProductPeriodPrice $periodPrice): self
  1704.     {
  1705.         if (!$this->periodPrice->contains($periodPrice)) {
  1706.             $this->periodPrice[] = $periodPrice;
  1707.             $periodPrice->setProduct($this);
  1708.         }
  1710.         return $this;
  1711.     }
  1712.     public function removePeriodPrice(ProductPeriodPrice $periodPrice): self
  1713.     {
  1714.         if ($this->periodPrice->removeElement($periodPrice)) {
  1715.             // set the owning side to null (unless already changed)
  1716.             if ($periodPrice->getProduct() === $this) {
  1717.                 $periodPrice->setProduct(null);
  1718.             }
  1719.         }
  1721.         return $this;
  1722.     }
  1723.     public function getCityLocalisation(): ?string
  1724.     {
  1725.         return $this->cityLocalisation;
  1726.     }
  1728.     public function setCityLocalisation(?string $cityLocalisation): self
  1729.     {
  1730.         $this->cityLocalisation = $cityLocalisation;
  1732.         return $this;
  1733.     }
  1735.     public function getNbChambre(): ?int
  1736.     {
  1737.         return $this->nbChambre;
  1738.     }
  1740.     public function setNbChambre(?int $nbChambre): self
  1741.     {
  1742.         $this->nbChambre = $nbChambre;
  1744.         return $this;
  1745.     }
  1747.     public function getNightMin(): ?int
  1748.     {
  1749.         return $this->nightMin;
  1750.     }
  1752.     public function setNightMin(?int $nightMin): self
  1753.     {
  1754.         $this->nightMin = $nightMin;
  1756.         return $this;
  1757.     }
  1759.     /**
  1760.      * @return Collection<int, TarifDegressif>
  1761.      */
  1762.     public function getTarifDegressifs(): Collection
  1763.     {
  1764.         return $this->tarifDegressifs;
  1765.     }
  1767.     public function addTarifDegressif(TarifDegressif $tarifDegressif): self
  1768.     {
  1769.         if (!$this->tarifDegressifs->contains($tarifDegressif)) {
  1770.             $this->tarifDegressifs[] = $tarifDegressif;
  1771.             $tarifDegressif->setProduct($this);
  1772.         }
  1774.         return $this;
  1775.     }
  1777.     public function removeTarifDegressif(TarifDegressif $tarifDegressif): self
  1778.     {
  1779.         if ($this->tarifDegressifs->removeElement($tarifDegressif)) {
  1780.             // set the owning side to null (unless already changed)
  1781.             if ($tarifDegressif->getProduct() === $this) {
  1782.                 $tarifDegressif->setProduct(null);
  1783.             }
  1784.         }
  1786.         return $this;
  1787.     }
  1789.     /**
  1790.      * @return Collection<int, EquipementsCuisine>
  1791.      */
  1792.     public function getEquipementsCuisines(): Collection
  1793.     {
  1794.         return $this->equipementsCuisines;
  1795.     }
  1797.     public function addEquipementsCuisine(EquipementsCuisine $equipementsCuisine): self
  1798.     {
  1799.         if (!$this->equipementsCuisines->contains($equipementsCuisine)) {
  1800.             $this->equipementsCuisines[] = $equipementsCuisine;
  1801.             $equipementsCuisine->addProduct($this);
  1802.         }
  1804.         return $this;
  1805.     }
  1807.     public function removeEquipementsCuisine(EquipementsCuisine $equipementsCuisine): self
  1808.     {
  1809.         if ($this->equipementsCuisines->removeElement($equipementsCuisine)) {
  1810.             $equipementsCuisine->removeProduct($this);
  1811.         }
  1813.         return $this;
  1814.     }
  1816.     /**
  1817.      * @return Collection<int, SalleDeBain>
  1818.      */
  1819.     public function getSalleDeBains(): Collection
  1820.     {
  1821.         return $this->salleDeBains;
  1822.     }
  1824.     public function addSalleDeBain(SalleDeBain $salleDeBain): self
  1825.     {
  1826.         if (!$this->salleDeBains->contains($salleDeBain)) {
  1827.             $this->salleDeBains[] = $salleDeBain;
  1828.             $salleDeBain->addProduct($this);
  1829.         }
  1831.         return $this;
  1832.     }
  1834.     public function removeSalleDeBain(SalleDeBain $salleDeBain): self
  1835.     {
  1836.         if ($this->salleDeBains->removeElement($salleDeBain)) {
  1837.             $salleDeBain->removeProduct($this);
  1838.         }
  1840.         return $this;
  1841.     }
  1843.     /**
  1844.      * @return Collection<int, AccessoiresDeChambre>
  1845.      */
  1846.     public function getAccessoiresDeChambres(): Collection
  1847.     {
  1848.         return $this->accessoiresDeChambres;
  1849.     }
  1851.     public function addAccessoiresDeChambre(AccessoiresDeChambre $accessoiresDeChambre): self
  1852.     {
  1853.         if (!$this->accessoiresDeChambres->contains($accessoiresDeChambre)) {
  1854.             $this->accessoiresDeChambres[] = $accessoiresDeChambre;
  1855.             $accessoiresDeChambre->addProduct($this);
  1856.         }
  1858.         return $this;
  1859.     }
  1861.     public function removeAccessoiresDeChambre(AccessoiresDeChambre $accessoiresDeChambre): self
  1862.     {
  1863.         if ($this->accessoiresDeChambres->removeElement($accessoiresDeChambre)) {
  1864.             $accessoiresDeChambre->removeProduct($this);
  1865.         }
  1867.         return $this;
  1868.     }
  1870.     /**
  1871.      * @return Collection<int, MobilierExterieur>
  1872.      */
  1873.     public function getMobilierExterieurs(): Collection
  1874.     {
  1875.         return $this->mobilierExterieurs;
  1876.     }
  1878.     public function addMobilierExterieur(MobilierExterieur $mobilierExterieur): self
  1879.     {
  1880.         if (!$this->mobilierExterieurs->contains($mobilierExterieur)) {
  1881.             $this->mobilierExterieurs[] = $mobilierExterieur;
  1882.             $mobilierExterieur->addProduct($this);
  1883.         }
  1885.         return $this;
  1886.     }
  1888.     public function removeMobilierExterieur(MobilierExterieur $mobilierExterieur): self
  1889.     {
  1890.         if ($this->mobilierExterieurs->removeElement($mobilierExterieur)) {
  1891.             $mobilierExterieur->removeProduct($this);
  1892.         }
  1894.         return $this;
  1895.     }
  1897.     public function getCaracteristiqueVehicule(): ?CaracteristiqueVehicule
  1898.     {
  1899.         return $this->caracteristiqueVehicule;
  1900.     }
  1902.     public function setCaracteristiqueVehicule(?CaracteristiqueVehicule $caracteristiqueVehicule): self
  1903.     {
  1904.         $this->caracteristiqueVehicule = $caracteristiqueVehicule;
  1906.         return $this;
  1907.     }
  1909.     /**
  1910.      * @return Collection<int, Notification>
  1911.      */
  1912.     public function getNotificationReservation(): Collection
  1913.     {
  1914.         return $this->notificationReservation;
  1915.     }
  1917.     public function addNotificationReservation(Notification $notificationReservation): self
  1918.     {
  1919.         if (!$this->notificationReservation->contains($notificationReservation)) {
  1920.             $this->notificationReservation[] = $notificationReservation;
  1921.             $notificationReservation->setProduct($this);
  1922.         }
  1924.         return $this;
  1925.     }
  1927.     public function removeNotificationReservation(Notification $notificationReservation): self
  1928.     {
  1929.         if ($this->notificationReservation->removeElement($notificationReservation)) {
  1930.             // set the owning side to null (unless already changed)
  1931.             if ($notificationReservation->getProduct() === $this) {
  1932.                 $notificationReservation->setProduct(null);
  1933.             }
  1934.         }
  1936.         return $this;
  1937.     }
  1939.     public function getCommune(): ?Commune
  1940.     {
  1941.         return $this->commune;
  1942.     }
  1944.     public function setCommune(?Commune $commune): self
  1945.     {
  1946.         $this->commune = $commune;
  1948.         return $this;
  1949.     }
  1951.     public function getLocalisatioHebergs(): Collection
  1952.     {
  1953.         return $this->localisatioHebergs;
  1954.     }
  1956.     public function addLocalisatioHebergs(LocalisatioHebergs $localisatioHebergs): self
  1957.     {
  1958.         if (!$this->localisatioHebergs->contains($localisatioHebergs)) {
  1959.             $this->localisatioHebergs[] = $localisatioHebergs;
  1960.         }
  1961.         return $this;
  1962.     }
  1964.     public function removeLocalisatioHebergs(LocalisatioHebergs $localisatioHebergs): self
  1965.     {
  1966.         $this->localisatioHebergs->removeElement($localisatioHebergs);
  1967.         return $this;
  1968.     }
  1969. }