src/Entity/Product.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProductRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=ProductRepository::class)
  12.  */
  13. class Product
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255)
  24.      */
  25.     private $name;
  27.     /**
  28.      * @ORM\Column(type="text", nullable=true)
  29.      */
  30.     private $description;
  32.     /**
  33.      * @ORM\Column(type="string", length=255, nullable=true)
  34.      */
  35.     private $cip7;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $cip13;
  42.     /**
  43.      * @ORM\Column(type="float", nullable=true)
  44.      */
  45.     private $pricegrossiste;
  47.     /**
  48.      * @ORM\Column(type="float", nullable=true)
  49.      */
  50.     private $pricepharmacie;
  52.     /**
  53.      * @ORM\Column(type="integer", nullable=true)
  54.      */
  55.     private $quantity;
  57.     /**
  58.      * @ORM\Column(type="string", length=255, nullable=true)
  59.      */
  60.     private $collissage;
  62.     /**
  63.      * @ORM\Column(type="integer", nullable=true)
  64.      */
  65.     private $quantitymin;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      */
  70.     private $amm;
  72.     /**
  73.      * @ORM\Column(type="string", length=255, nullable=true)
  74.      */
  75.     private $cg;
  77.     /**
  78.      * @ORM\Column(type="string", length=255, nullable=true)
  79.      */
  80.     private $disponibilite;
  82.     /**
  83.      * @ORM\ManyToOne(targetEntity=Category::class, inversedBy="products")
  84.      */
  85.     private $category;
  88.     /**
  89.      * @ORM\ManyToOne(targetEntity=Speciality::class, inversedBy="products")
  90.      */
  91.     private $specialite;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity=PropositionDetails::class, mappedBy="product")
  95.      */
  96.     private $propositionDetails;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=OrderDetails::class, mappedBy="product_id")
  100.      */
  101.     private $orderDetails;
  103.     /**
  104.      * @ORM\ManyToOne(targetEntity=ColisageType::class, inversedBy="products")
  105.      */
  106.     private $colisageType;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=Cart::class, mappedBy="produit")
  110.      */
  111.     private $carts;
  113.     /**
  114.      * @ORM\Column(type="string", length=255, nullable=true)
  115.      */
  116.     private $pays;
  118.     /**
  119.      * @ORM\ManyToOne(targetEntity=DeclinaisonForm::class, inversedBy="products")
  120.      */
  121.     private $declinaisonform;
  123.     /**
  124.      * @ORM\Column(type="integer", nullable=true)
  125.      */
  126.     private $previsionarrivage;
  128.     /**
  129.      * @ORM\ManyToOne(targetEntity=Pays::class, inversedBy="products")
  130.      */
  131.     private $payslocalisation;
  133.     /**
  134.      * @ORM\ManyToOne(targetEntity=Laboratoire::class, inversedBy="products")
  135.      */
  136.     private $laboratoire;
  138.     /**
  139.      * @ORM\Column(type="text", nullable=true)
  140.      */
  141.     private $indication;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=ForecastDetails::class, mappedBy="produit_id")
  145.      */
  146.     private $forecastDetails;
  148.     /**
  149.      * @ORM\OneToMany(targetEntity=Photo::class, mappedBy="produit")
  150.      */
  151.     private $photos;
  153.     /**
  154.      * @ORM\OneToMany(targetEntity=Stockpharmacie::class, mappedBy="produit")
  155.      */
  156.     private $stockpharmacies;
  158.     /**
  159.      * @ORM\Column(type="text", nullable=true)
  160.      */
  161.     private $posologie;
  163.     /**
  164.      * @ORM\Column(type="datetime", nullable=true)
  165.      */
  166.     private $createdAt;
  168.     /**
  169.      * @ORM\Column(type="boolean", nullable=true)
  170.      */
  171.     private $isStockPharmacie;
  173.     /**
  174.      * @ORM\Column(type="boolean", nullable=true)
  175.      */
  176.     private $isOrdonnance;
  178.     /**
  179.      * @ORM\Column(type="boolean", nullable=true)
  180.      */
  181.     private $isPhotoNotFound;
  183.     /**
  184.      * @ORM\Column(type="boolean", nullable=true)
  185.      */
  186.     private $isDoublon;
  188.     /**
  189.      * @ORM\OneToMany(targetEntity=SearchHistory::class, mappedBy="clickAfter")
  190.      */
  191.     private $searchHistories;
  193.     /**
  194.      * @ORM\ManyToOne(targetEntity=SousCategorie::class, inversedBy="products")
  195.      */
  196.     private $souscategorie;
  198.     /**
  199.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="product")
  200.      */
  201.     private $favorites;
  203.     public function __construct()
  204.     {
  205.         $this->propositionDetails = new ArrayCollection();
  206.         $this->orderDetails = new ArrayCollection();
  207.         $this->carts = new ArrayCollection();
  208.         $this->forecastDetails = new ArrayCollection();
  209.         $this->photos = new ArrayCollection();
  210.         $this->stockpharmacies = new ArrayCollection();
  211.         $this->createdAt = new \DateTime();
  212.         $this->searchHistories = new ArrayCollection();
  213.         $this->favorites = new ArrayCollection();
  214.     }
  216.     public function __toString()
  217.     {
  218.         return $this->getName();
  219.     }
  221.     public function getId(): ?int
  222.     {
  223.         return $this->id;
  224.     }
  226.     public function getName(): ?string
  227.     {
  228.         return $this->name;
  229.     }
  231.     public function setName(string $name): self
  232.     {
  233.         $this->name = $name;
  235.         return $this;
  236.     }
  238.     public function getDescription(): ?string
  239.     {
  240.         return $this->description;
  241.     }
  243.     public function setDescription(?string $description): self
  244.     {
  245.         $this->description = $description;
  247.         return $this;
  248.     }
  250.     public function getCip7(): ?string
  251.     {
  252.         return $this->cip7;
  253.     }
  255.     public function setCip7(?string $cip7): self
  256.     {
  257.         $this->cip7 = $cip7;
  259.         return $this;
  260.     }
  262.     public function getCip13(): ?string
  263.     {
  264.         return $this->cip13;
  265.     }
  267.     public function setCip13(?string $cip13): self
  268.     {
  269.         $this->cip13 = $cip13;
  271.         return $this;
  272.     }
  274.     public function getPricegrossiste(): ?float
  275.     {
  276.         return $this->pricegrossiste;
  277.     }
  279.     public function setPricegrossiste(?float $pricegrossiste): self
  280.     {
  281.         $this->pricegrossiste = $pricegrossiste;
  283.         return $this;
  284.     }
  286.     public function getPricepharmacie(): ?float
  287.     {
  288.         return $this->pricepharmacie;
  289.     }
  291.     public function setPricepharmacie(?float $pricepharmacie): self
  292.     {
  293.         $this->pricepharmacie = $pricepharmacie;
  295.         return $this;
  296.     }
  298.     public function getQuantity(): ?int
  299.     {
  300.         return $this->quantity;
  301.     }
  303.     public function setQuantity(?int $quantity): self
  304.     {
  305.         $this->quantity = $quantity;
  307.         return $this;
  308.     }
  310.     public function getCollissage(): ?string
  311.     {
  312.         return $this->collissage;
  313.     }
  315.     public function setCollissage(?string $collissage): self
  316.     {
  317.         $this->collissage = $collissage;
  319.         return $this;
  320.     }
  322.     public function getQuantitymin(): ?int
  323.     {
  324.         return $this->quantitymin;
  325.     }
  327.     public function setQuantitymin(?int $quantitymin): self
  328.     {
  329.         $this->quantitymin = $quantitymin;
  331.         return $this;
  332.     }
  334.     public function getAmm(): ?string
  335.     {
  336.         return $this->amm;
  337.     }
  339.     public function setAmm(?string $amm): self
  340.     {
  341.         $this->amm = $amm;
  343.         return $this;
  344.     }
  346.     public function getCg(): ?string
  347.     {
  348.         return $this->cg;
  349.     }
  351.     public function setCg(?string $cg): self
  352.     {
  353.         $this->cg = $cg;
  355.         return $this;
  356.     }
  358.     public function getDisponibilite(): ?string
  359.     {
  360.         return $this->disponibilite;
  361.     }
  363.     public function setDisponibilite(?string $disponibilite): self
  364.     {
  365.         $this->disponibilite = $disponibilite;
  367.         return $this;
  368.     }
  370.     public function getCategory(): ?Category
  371.     {
  372.         return $this->category;
  373.     }
  375.     public function setCategory(?Category $category): self
  376.     {
  377.         $this->category = $category;
  379.         return $this;
  380.     }
  383.     public function getSpecialite(): ?Speciality
  384.     {
  385.         return $this->specialite;
  386.     }
  388.     public function setSpecialite(?Speciality $specialite): self
  389.     {
  390.         $this->specialite = $specialite;
  392.         return $this;
  393.     }
  395.     /**
  396.      * @return Collection<int, PropositionDetails>
  397.      */
  398.     public function getPropositionDetails(): Collection
  399.     {
  400.         return $this->propositionDetails;
  401.     }
  403.     public function addPropositionDetail(PropositionDetails $propositionDetail): self
  404.     {
  405.         if (!$this->propositionDetails->contains($propositionDetail)) {
  406.             $this->propositionDetails[] = $propositionDetail;
  407.             $propositionDetail->setProduct($this);
  408.         }
  410.         return $this;
  411.     }
  413.     public function removePropositionDetail(PropositionDetails $propositionDetail): self
  414.     {
  415.         if ($this->propositionDetails->removeElement($propositionDetail)) {
  416.             // set the owning side to null (unless already changed)
  417.             if ($propositionDetail->getProduct() === $this) {
  418.                 $propositionDetail->setProduct(null);
  419.             }
  420.         }
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, OrderDetails>
  427.      */
  428.     public function getOrderDetails(): Collection
  429.     {
  430.         return $this->orderDetails;
  431.     }
  433.     public function addOrderDetail(OrderDetails $orderDetail): self
  434.     {
  435.         if (!$this->orderDetails->contains($orderDetail)) {
  436.             $this->orderDetails[] = $orderDetail;
  437.             $orderDetail->setProductId($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeOrderDetail(OrderDetails $orderDetail): self
  444.     {
  445.         if ($this->orderDetails->removeElement($orderDetail)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($orderDetail->getProductId() === $this) {
  448.                 $orderDetail->setProductId(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     public function getColisageType(): ?ColisageType
  456.     {
  457.         return $this->colisageType;
  458.     }
  460.     public function setColisageType(?ColisageType $colisageType): self
  461.     {
  462.         $this->colisageType = $colisageType;
  464.         return $this;
  465.     }
  467.     /**
  468.      * @return Collection<int, Cart>
  469.      */
  470.     public function getCarts(): Collection
  471.     {
  472.         return $this->carts;
  473.     }
  475.     public function addCart(Cart $cart): self
  476.     {
  477.         if (!$this->carts->contains($cart)) {
  478.             $this->carts[] = $cart;
  479.             $cart->setProduit($this);
  480.         }
  482.         return $this;
  483.     }
  485.     public function removeCart(Cart $cart): self
  486.     {
  487.         if ($this->carts->removeElement($cart)) {
  488.             // set the owning side to null (unless already changed)
  489.             if ($cart->getProduit() === $this) {
  490.                 $cart->setProduit(null);
  491.             }
  492.         }
  494.         return $this;
  495.     }
  497.     public function getPays(): ?string
  498.     {
  499.         return $this->pays;
  500.     }
  502.     public function setPays(?string $pays): self
  503.     {
  504.         $this->pays = $pays;
  506.         return $this;
  507.     }
  509.     public function getDeclinaisonform(): ?DeclinaisonForm
  510.     {
  511.         return $this->declinaisonform;
  512.     }
  514.     public function setDeclinaisonform(?DeclinaisonForm $declinaisonform): self
  515.     {
  516.         $this->declinaisonform = $declinaisonform;
  518.         return $this;
  519.     }
  521.     public function getPrevisionarrivage(): ?int
  522.     {
  523.         return $this->previsionarrivage;
  524.     }
  526.     public function setPrevisionarrivage(?int $previsionarrivage): self
  527.     {
  528.         $this->previsionarrivage = $previsionarrivage;
  530.         return $this;
  531.     }
  533.     public function getPayslocalisation(): ?Pays
  534.     {
  535.         return $this->payslocalisation;
  536.     }
  538.     public function setPayslocalisation(?Pays $payslocalisation): self
  539.     {
  540.         $this->payslocalisation = $payslocalisation;
  542.         return $this;
  543.     }
  545.     public function getLaboratoire(): ?Laboratoire
  546.     {
  547.         return $this->laboratoire;
  548.     }
  550.     public function setLaboratoire(?Laboratoire $laboratoire): self
  551.     {
  552.         $this->laboratoire = $laboratoire;
  554.         return $this;
  555.     }
  557.     public function getIndication(): ?string
  558.     {
  559.         return $this->indication;
  560.     }
  562.     public function setIndication(?string $indication): self
  563.     {
  564.         $this->indication = $indication;
  566.         return $this;
  567.     }
  569.     /**
  570.      * @return Collection<int, ForecastDetails>
  571.      */
  572.     public function getForecastDetails(): Collection
  573.     {
  574.         return $this->forecastDetails;
  575.     }
  577.     public function addForecastDetail(ForecastDetails $forecastDetail): self
  578.     {
  579.         if (!$this->forecastDetails->contains($forecastDetail)) {
  580.             $this->forecastDetails[] = $forecastDetail;
  581.             $forecastDetail->setProduitId($this);
  582.         }
  584.         return $this;
  585.     }
  587.     public function removeForecastDetail(ForecastDetails $forecastDetail): self
  588.     {
  589.         if ($this->forecastDetails->removeElement($forecastDetail)) {
  590.             // set the owning side to null (unless already changed)
  591.             if ($forecastDetail->getProduitId() === $this) {
  592.                 $forecastDetail->setProduitId(null);
  593.             }
  594.         }
  596.         return $this;
  597.     }
  599.     /**
  600.      * @return Collection<int, Photo>
  601.      */
  602.     public function getPhotos(): Collection
  603.     {
  604.         return $this->photos;
  605.     }
  607.     public function addPhoto(Photo $photo): self
  608.     {
  609.         if (!$this->photos->contains($photo)) {
  610.             $this->photos[] = $photo;
  611.             $photo->setProduit($this);
  612.         }
  614.         return $this;
  615.     }
  617.     public function removePhoto(Photo $photo): self
  618.     {
  619.         if ($this->photos->removeElement($photo)) {
  620.             // set the owning side to null (unless already changed)
  621.             if ($photo->getProduit() === $this) {
  622.                 $photo->setProduit(null);
  623.             }
  624.         }
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, Stockpharmacie>
  631.      */
  632.     public function getStockpharmacies(): Collection
  633.     {
  634.         return $this->stockpharmacies;
  635.     }
  637.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  638.     {
  639.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  640.             $this->stockpharmacies[] = $stockpharmacy;
  641.             $stockpharmacy->setProduit($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  648.     {
  649.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($stockpharmacy->getProduit() === $this) {
  652.                 $stockpharmacy->setProduit(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  659.     public function getPosologie(): ?string
  660.     {
  661.         return $this->posologie;
  662.     }
  664.     public function setPosologie(?string $posologie): self
  665.     {
  666.         $this->posologie = $posologie;
  668.         return $this;
  669.     }
  671.     public function getCreatedAt(): ?\DateTimeInterface
  672.     {
  673.         return $this->createdAt;
  674.     }
  676.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  677.     {
  678.         $this->createdAt = $createdAt;
  680.         return $this;
  681.     }
  683.     public function isIsStockPharmacie(): ?bool
  684.     {
  685.         return $this->isStockPharmacie;
  686.     }
  688.     public function setIsStockPharmacie(?bool $isStockPharmacie): self
  689.     {
  690.         $this->isStockPharmacie = $isStockPharmacie;
  692.         return $this;
  693.     }
  695.     public function isIsOrdonnance(): ?bool
  696.     {
  697.         return $this->isOrdonnance;
  698.     }
  700.     public function setIsOrdonnance(?bool $isOrdonnance): self
  701.     {
  702.         $this->isOrdonnance = $isOrdonnance;
  704.         return $this;
  705.     }
  707.     public function isIsPhotoNotFound(): ?bool
  708.     {
  709.         return $this->isPhotoNotFound;
  710.     }
  712.     public function setIsPhotoNotFound(?bool $isPhotoNotFound): self
  713.     {
  714.         $this->isPhotoNotFound = $isPhotoNotFound;
  716.         return $this;
  717.     }
  719.     public function isIsDoublon(): ?bool
  720.     {
  721.         return $this->isDoublon;
  722.     }
  724.     public function setIsDoublon(?bool $isDoublon): self
  725.     {
  726.         $this->isDoublon = $isDoublon;
  728.         return $this;
  729.     }
  731.     /**
  732.      * @return Collection<int, SearchHistory>
  733.      */
  734.     public function getSearchHistories(): Collection
  735.     {
  736.         return $this->searchHistories;
  737.     }
  739.     public function addSearchHistory(SearchHistory $searchHistory): self
  740.     {
  741.         if (!$this->searchHistories->contains($searchHistory)) {
  742.             $this->searchHistories[] = $searchHistory;
  743.             $searchHistory->setClickAfter($this);
  744.         }
  746.         return $this;
  747.     }
  749.     public function removeSearchHistory(SearchHistory $searchHistory): self
  750.     {
  751.         if ($this->searchHistories->removeElement($searchHistory)) {
  752.             // set the owning side to null (unless already changed)
  753.             if ($searchHistory->getClickAfter() === $this) {
  754.                 $searchHistory->setClickAfter(null);
  755.             }
  756.         }
  758.         return $this;
  759.     }
  761.     public function getSouscategorie(): ?SousCategorie
  762.     {
  763.         return $this->souscategorie;
  764.     }
  766.     public function setSouscategorie(?SousCategorie $souscategorie): self
  767.     {
  768.         $this->souscategorie = $souscategorie;
  770.         return $this;
  771.     }
  773.     /**
  774.      * @return Collection<int, Favorite>
  775.      */
  776.     public function getFavorites(): Collection
  777.     {
  778.         return $this->favorites;
  779.     }
  781.     public function addFavorite(Favorite $favorite): self
  782.     {
  783.         if (!$this->favorites->contains($favorite)) {
  784.             $this->favorites[] = $favorite;
  785.             $favorite->setProduct($this);
  786.         }
  788.         return $this;
  789.     }
  791.     public function removeFavorite(Favorite $favorite): self
  792.     {
  793.         if ($this->favorites->removeElement($favorite)) {
  794.             // set the owning side to null (unless already changed)
  795.             if ($favorite->getProduct() === $this) {
  796.                 $favorite->setProduct(null);
  797.             }
  798.         }
  800.         return $this;
  801.     }
  803.     public function isMyFavorite(User $user): bool
  804.     {
  805.         foreach ($this->getFavorites() as $favorite) {
  806.             if ($favorite->getUser() === $user) {
  807.                 return true;
  808.             }
  809.         }
  810.         return false;
  811.     }
  813.     public function getPhoto(): ?Photo
  814.     {
  815.         if ($this->getPhotos()->count() > 0) {
  816.             return $this->getPhotos()->first();
  817.         }
  818.         return null;
  819.     }
  821.     public function isStockDisponible()
  822.     {
  823.         $disponibilite = null;
  824.         if ($this->getStockpharmacies()->count() > 0) {
  825.             $disponibilite = false;
  826.             foreach ($this->getStockpharmacies() as $stock) {
  827.                 if ($stock->isIsDisponible()) {
  828.                     $disponibilite = true;
  829.                     break;
  830.                 }
  831.             }
  832.         }
  833.         return $disponibilite;
  834.     }
  835. }