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.     /**
  204.      * @ORM\ManyToOne(targetEntity=ProductClass::class, inversedBy="products")
  205.      */
  206.     private $productClass;
  208.     public function __construct()
  209.     {
  210.         $this->propositionDetails = new ArrayCollection();
  211.         $this->orderDetails = new ArrayCollection();
  212.         $this->carts = new ArrayCollection();
  213.         $this->forecastDetails = new ArrayCollection();
  214.         $this->photos = new ArrayCollection();
  215.         $this->stockpharmacies = new ArrayCollection();
  216.         $this->createdAt = new \DateTime();
  217.         $this->searchHistories = new ArrayCollection();
  218.         $this->favorites = new ArrayCollection();
  219.     }
  221.     public function __toString()
  222.     {
  223.         return $this->getName();
  224.     }
  226.     public function getId(): ?int
  227.     {
  228.         return $this->id;
  229.     }
  231.     public function getName(): ?string
  232.     {
  233.         return $this->name;
  234.     }
  236.     public function setName(string $name): self
  237.     {
  238.         $this->name = $name;
  240.         return $this;
  241.     }
  243.     public function getDescription(): ?string
  244.     {
  245.         return $this->description;
  246.     }
  248.     public function setDescription(?string $description): self
  249.     {
  250.         $this->description = $description;
  252.         return $this;
  253.     }
  255.     public function getCip7(): ?string
  256.     {
  257.         return $this->cip7;
  258.     }
  260.     public function setCip7(?string $cip7): self
  261.     {
  262.         $this->cip7 = $cip7;
  264.         return $this;
  265.     }
  267.     public function getCip13(): ?string
  268.     {
  269.         return $this->cip13;
  270.     }
  272.     public function setCip13(?string $cip13): self
  273.     {
  274.         $this->cip13 = $cip13;
  276.         return $this;
  277.     }
  279.     public function getPricegrossiste(): ?float
  280.     {
  281.         return $this->pricegrossiste;
  282.     }
  284.     public function setPricegrossiste(?float $pricegrossiste): self
  285.     {
  286.         $this->pricegrossiste = $pricegrossiste;
  288.         return $this;
  289.     }
  291.     public function getPricepharmacie(): ?float
  292.     {
  293.         return $this->pricepharmacie;
  294.     }
  296.     public function setPricepharmacie(?float $pricepharmacie): self
  297.     {
  298.         $this->pricepharmacie = $pricepharmacie;
  300.         return $this;
  301.     }
  303.     public function getQuantity(): ?int
  304.     {
  305.         return $this->quantity;
  306.     }
  308.     public function setQuantity(?int $quantity): self
  309.     {
  310.         $this->quantity = $quantity;
  312.         return $this;
  313.     }
  315.     public function getCollissage(): ?string
  316.     {
  317.         return $this->collissage;
  318.     }
  320.     public function setCollissage(?string $collissage): self
  321.     {
  322.         $this->collissage = $collissage;
  324.         return $this;
  325.     }
  327.     public function getQuantitymin(): ?int
  328.     {
  329.         return $this->quantitymin;
  330.     }
  332.     public function setQuantitymin(?int $quantitymin): self
  333.     {
  334.         $this->quantitymin = $quantitymin;
  336.         return $this;
  337.     }
  339.     public function getAmm(): ?string
  340.     {
  341.         return $this->amm;
  342.     }
  344.     public function setAmm(?string $amm): self
  345.     {
  346.         $this->amm = $amm;
  348.         return $this;
  349.     }
  351.     public function getCg(): ?string
  352.     {
  353.         return $this->cg;
  354.     }
  356.     public function setCg(?string $cg): self
  357.     {
  358.         $this->cg = $cg;
  360.         return $this;
  361.     }
  363.     public function getDisponibilite(): ?string
  364.     {
  365.         return $this->disponibilite;
  366.     }
  368.     public function setDisponibilite(?string $disponibilite): self
  369.     {
  370.         $this->disponibilite = $disponibilite;
  372.         return $this;
  373.     }
  375.     public function getCategory(): ?Category
  376.     {
  377.         return $this->category;
  378.     }
  380.     public function setCategory(?Category $category): self
  381.     {
  382.         $this->category = $category;
  384.         return $this;
  385.     }
  388.     public function getSpecialite(): ?Speciality
  389.     {
  390.         return $this->specialite;
  391.     }
  393.     public function setSpecialite(?Speciality $specialite): self
  394.     {
  395.         $this->specialite = $specialite;
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection<int, PropositionDetails>
  402.      */
  403.     public function getPropositionDetails(): Collection
  404.     {
  405.         return $this->propositionDetails;
  406.     }
  408.     public function addPropositionDetail(PropositionDetails $propositionDetail): self
  409.     {
  410.         if (!$this->propositionDetails->contains($propositionDetail)) {
  411.             $this->propositionDetails[] = $propositionDetail;
  412.             $propositionDetail->setProduct($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removePropositionDetail(PropositionDetails $propositionDetail): self
  419.     {
  420.         if ($this->propositionDetails->removeElement($propositionDetail)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($propositionDetail->getProduct() === $this) {
  423.                 $propositionDetail->setProduct(null);
  424.             }
  425.         }
  427.         return $this;
  428.     }
  430.     /**
  431.      * @return Collection<int, OrderDetails>
  432.      */
  433.     public function getOrderDetails(): Collection
  434.     {
  435.         return $this->orderDetails;
  436.     }
  438.     public function addOrderDetail(OrderDetails $orderDetail): self
  439.     {
  440.         if (!$this->orderDetails->contains($orderDetail)) {
  441.             $this->orderDetails[] = $orderDetail;
  442.             $orderDetail->setProductId($this);
  443.         }
  445.         return $this;
  446.     }
  448.     public function removeOrderDetail(OrderDetails $orderDetail): self
  449.     {
  450.         if ($this->orderDetails->removeElement($orderDetail)) {
  451.             // set the owning side to null (unless already changed)
  452.             if ($orderDetail->getProductId() === $this) {
  453.                 $orderDetail->setProductId(null);
  454.             }
  455.         }
  457.         return $this;
  458.     }
  460.     public function getColisageType(): ?ColisageType
  461.     {
  462.         return $this->colisageType;
  463.     }
  465.     public function setColisageType(?ColisageType $colisageType): self
  466.     {
  467.         $this->colisageType = $colisageType;
  469.         return $this;
  470.     }
  472.     /**
  473.      * @return Collection<int, Cart>
  474.      */
  475.     public function getCarts(): Collection
  476.     {
  477.         return $this->carts;
  478.     }
  480.     public function addCart(Cart $cart): self
  481.     {
  482.         if (!$this->carts->contains($cart)) {
  483.             $this->carts[] = $cart;
  484.             $cart->setProduit($this);
  485.         }
  487.         return $this;
  488.     }
  490.     public function removeCart(Cart $cart): self
  491.     {
  492.         if ($this->carts->removeElement($cart)) {
  493.             // set the owning side to null (unless already changed)
  494.             if ($cart->getProduit() === $this) {
  495.                 $cart->setProduit(null);
  496.             }
  497.         }
  499.         return $this;
  500.     }
  502.     public function getPays(): ?string
  503.     {
  504.         return $this->pays;
  505.     }
  507.     public function setPays(?string $pays): self
  508.     {
  509.         $this->pays = $pays;
  511.         return $this;
  512.     }
  514.     public function getDeclinaisonform(): ?DeclinaisonForm
  515.     {
  516.         return $this->declinaisonform;
  517.     }
  519.     public function setDeclinaisonform(?DeclinaisonForm $declinaisonform): self
  520.     {
  521.         $this->declinaisonform = $declinaisonform;
  523.         return $this;
  524.     }
  526.     public function getPrevisionarrivage(): ?int
  527.     {
  528.         return $this->previsionarrivage;
  529.     }
  531.     public function setPrevisionarrivage(?int $previsionarrivage): self
  532.     {
  533.         $this->previsionarrivage = $previsionarrivage;
  535.         return $this;
  536.     }
  538.     public function getPayslocalisation(): ?Pays
  539.     {
  540.         return $this->payslocalisation;
  541.     }
  543.     public function setPayslocalisation(?Pays $payslocalisation): self
  544.     {
  545.         $this->payslocalisation = $payslocalisation;
  547.         return $this;
  548.     }
  550.     public function getLaboratoire(): ?Laboratoire
  551.     {
  552.         return $this->laboratoire;
  553.     }
  555.     public function setLaboratoire(?Laboratoire $laboratoire): self
  556.     {
  557.         $this->laboratoire = $laboratoire;
  559.         return $this;
  560.     }
  562.     public function getIndication(): ?string
  563.     {
  564.         return $this->indication;
  565.     }
  567.     public function setIndication(?string $indication): self
  568.     {
  569.         $this->indication = $indication;
  571.         return $this;
  572.     }
  574.     /**
  575.      * @return Collection<int, ForecastDetails>
  576.      */
  577.     public function getForecastDetails(): Collection
  578.     {
  579.         return $this->forecastDetails;
  580.     }
  582.     public function addForecastDetail(ForecastDetails $forecastDetail): self
  583.     {
  584.         if (!$this->forecastDetails->contains($forecastDetail)) {
  585.             $this->forecastDetails[] = $forecastDetail;
  586.             $forecastDetail->setProduitId($this);
  587.         }
  589.         return $this;
  590.     }
  592.     public function removeForecastDetail(ForecastDetails $forecastDetail): self
  593.     {
  594.         if ($this->forecastDetails->removeElement($forecastDetail)) {
  595.             // set the owning side to null (unless already changed)
  596.             if ($forecastDetail->getProduitId() === $this) {
  597.                 $forecastDetail->setProduitId(null);
  598.             }
  599.         }
  601.         return $this;
  602.     }
  604.     /**
  605.      * @return Collection<int, Photo>
  606.      */
  607.     public function getPhotos(): Collection
  608.     {
  609.         return $this->photos;
  610.     }
  612.     public function addPhoto(Photo $photo): self
  613.     {
  614.         if (!$this->photos->contains($photo)) {
  615.             $this->photos[] = $photo;
  616.             $photo->setProduit($this);
  617.         }
  619.         return $this;
  620.     }
  622.     public function removePhoto(Photo $photo): self
  623.     {
  624.         if ($this->photos->removeElement($photo)) {
  625.             // set the owning side to null (unless already changed)
  626.             if ($photo->getProduit() === $this) {
  627.                 $photo->setProduit(null);
  628.             }
  629.         }
  631.         return $this;
  632.     }
  634.     /**
  635.      * @return Collection<int, Stockpharmacie>
  636.      */
  637.     public function getStockpharmacies(): Collection
  638.     {
  639.         return $this->stockpharmacies;
  640.     }
  642.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  643.     {
  644.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  645.             $this->stockpharmacies[] = $stockpharmacy;
  646.             $stockpharmacy->setProduit($this);
  647.         }
  649.         return $this;
  650.     }
  652.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  653.     {
  654.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  655.             // set the owning side to null (unless already changed)
  656.             if ($stockpharmacy->getProduit() === $this) {
  657.                 $stockpharmacy->setProduit(null);
  658.             }
  659.         }
  661.         return $this;
  662.     }
  664.     public function getPosologie(): ?string
  665.     {
  666.         return $this->posologie;
  667.     }
  669.     public function setPosologie(?string $posologie): self
  670.     {
  671.         $this->posologie = $posologie;
  673.         return $this;
  674.     }
  676.     public function getCreatedAt(): ?\DateTimeInterface
  677.     {
  678.         return $this->createdAt;
  679.     }
  681.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  682.     {
  683.         $this->createdAt = $createdAt;
  685.         return $this;
  686.     }
  688.     public function isIsStockPharmacie(): ?bool
  689.     {
  690.         return $this->isStockPharmacie;
  691.     }
  693.     public function setIsStockPharmacie(?bool $isStockPharmacie): self
  694.     {
  695.         $this->isStockPharmacie = $isStockPharmacie;
  697.         return $this;
  698.     }
  700.     public function isIsOrdonnance(): ?bool
  701.     {
  702.         return $this->isOrdonnance;
  703.     }
  705.     public function setIsOrdonnance(?bool $isOrdonnance): self
  706.     {
  707.         $this->isOrdonnance = $isOrdonnance;
  709.         return $this;
  710.     }
  712.     public function isIsPhotoNotFound(): ?bool
  713.     {
  714.         return $this->isPhotoNotFound;
  715.     }
  717.     public function setIsPhotoNotFound(?bool $isPhotoNotFound): self
  718.     {
  719.         $this->isPhotoNotFound = $isPhotoNotFound;
  721.         return $this;
  722.     }
  724.     public function isIsDoublon(): ?bool
  725.     {
  726.         return $this->isDoublon;
  727.     }
  729.     public function setIsDoublon(?bool $isDoublon): self
  730.     {
  731.         $this->isDoublon = $isDoublon;
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return Collection<int, SearchHistory>
  738.      */
  739.     public function getSearchHistories(): Collection
  740.     {
  741.         return $this->searchHistories;
  742.     }
  744.     public function addSearchHistory(SearchHistory $searchHistory): self
  745.     {
  746.         if (!$this->searchHistories->contains($searchHistory)) {
  747.             $this->searchHistories[] = $searchHistory;
  748.             $searchHistory->setClickAfter($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeSearchHistory(SearchHistory $searchHistory): self
  755.     {
  756.         if ($this->searchHistories->removeElement($searchHistory)) {
  757.             // set the owning side to null (unless already changed)
  758.             if ($searchHistory->getClickAfter() === $this) {
  759.                 $searchHistory->setClickAfter(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     public function getSouscategorie(): ?SousCategorie
  767.     {
  768.         return $this->souscategorie;
  769.     }
  771.     public function setSouscategorie(?SousCategorie $souscategorie): self
  772.     {
  773.         $this->souscategorie = $souscategorie;
  775.         return $this;
  776.     }
  778.     /**
  779.      * @return Collection<int, Favorite>
  780.      */
  781.     public function getFavorites(): Collection
  782.     {
  783.         return $this->favorites;
  784.     }
  786.     public function addFavorite(Favorite $favorite): self
  787.     {
  788.         if (!$this->favorites->contains($favorite)) {
  789.             $this->favorites[] = $favorite;
  790.             $favorite->setProduct($this);
  791.         }
  793.         return $this;
  794.     }
  796.     public function removeFavorite(Favorite $favorite): self
  797.     {
  798.         if ($this->favorites->removeElement($favorite)) {
  799.             // set the owning side to null (unless already changed)
  800.             if ($favorite->getProduct() === $this) {
  801.                 $favorite->setProduct(null);
  802.             }
  803.         }
  805.         return $this;
  806.     }
  808.     public function isMyFavorite(User $user): bool
  809.     {
  810.         foreach ($this->getFavorites() as $favorite) {
  811.             if ($favorite->getUser() === $user) {
  812.                 return true;
  813.             }
  814.         }
  815.         return false;
  816.     }
  818.     public function getPhoto(): ?Photo
  819.     {
  820.         if ($this->getPhotos()->count() > 0) {
  821.             return $this->getPhotos()->first();
  822.         }
  823.         return null;
  824.     }
  826.     public function isStockDisponible()
  827.     {
  828.         $disponibilite = null;
  829.         if ($this->getStockpharmacies()->count() > 0) {
  830.             $disponibilite = false;
  831.             foreach ($this->getStockpharmacies() as $stock) {
  832.                 if ($stock->isIsDisponible()) {
  833.                     $disponibilite = true;
  834.                     break;
  835.                 }
  836.             }
  837.         }
  838.         return $disponibilite;
  839.     }
  841.     public function getProductClass(): ?ProductClass
  842.     {
  843.         return $this->productClass;
  844.     }
  846.     public function setProductClass(?ProductClass $productClass): self
  847.     {
  848.         $this->productClass = $productClass;
  850.         return $this;
  851.     }
  852. }