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.     public function __construct()
  194.     {
  195.         $this->propositionDetails = new ArrayCollection();
  196.         $this->orderDetails = new ArrayCollection();
  197.         $this->carts = new ArrayCollection();
  198.         $this->forecastDetails = new ArrayCollection();
  199.         $this->photos = new ArrayCollection();
  200.         $this->stockpharmacies = new ArrayCollection();
  201.         $this->createdAt = new \DateTime();
  202.         $this->searchHistories = new ArrayCollection();
  203.     }
  205.     public function __toString()
  206.     {
  207.         return $this->getName();
  208.     }
  210.     public function getId(): ?int
  211.     {
  212.         return $this->id;
  213.     }
  215.     public function getName(): ?string
  216.     {
  217.         return $this->name;
  218.     }
  220.     public function setName(string $name): self
  221.     {
  222.         $this->name = $name;
  224.         return $this;
  225.     }
  227.     public function getDescription(): ?string
  228.     {
  229.         return $this->description;
  230.     }
  232.     public function setDescription(?string $description): self
  233.     {
  234.         $this->description = $description;
  236.         return $this;
  237.     }
  239.     public function getCip7(): ?string
  240.     {
  241.         return $this->cip7;
  242.     }
  244.     public function setCip7(?string $cip7): self
  245.     {
  246.         $this->cip7 = $cip7;
  248.         return $this;
  249.     }
  251.     public function getCip13(): ?string
  252.     {
  253.         return $this->cip13;
  254.     }
  256.     public function setCip13(?string $cip13): self
  257.     {
  258.         $this->cip13 = $cip13;
  260.         return $this;
  261.     }
  263.     public function getPricegrossiste(): ?float
  264.     {
  265.         return $this->pricegrossiste;
  266.     }
  268.     public function setPricegrossiste(?float $pricegrossiste): self
  269.     {
  270.         $this->pricegrossiste = $pricegrossiste;
  272.         return $this;
  273.     }
  275.     public function getPricepharmacie(): ?float
  276.     {
  277.         return $this->pricepharmacie;
  278.     }
  280.     public function setPricepharmacie(?float $pricepharmacie): self
  281.     {
  282.         $this->pricepharmacie = $pricepharmacie;
  284.         return $this;
  285.     }
  287.     public function getQuantity(): ?int
  288.     {
  289.         return $this->quantity;
  290.     }
  292.     public function setQuantity(?int $quantity): self
  293.     {
  294.         $this->quantity = $quantity;
  296.         return $this;
  297.     }
  299.     public function getCollissage(): ?string
  300.     {
  301.         return $this->collissage;
  302.     }
  304.     public function setCollissage(?string $collissage): self
  305.     {
  306.         $this->collissage = $collissage;
  308.         return $this;
  309.     }
  311.     public function getQuantitymin(): ?int
  312.     {
  313.         return $this->quantitymin;
  314.     }
  316.     public function setQuantitymin(?int $quantitymin): self
  317.     {
  318.         $this->quantitymin = $quantitymin;
  320.         return $this;
  321.     }
  323.     public function getAmm(): ?string
  324.     {
  325.         return $this->amm;
  326.     }
  328.     public function setAmm(?string $amm): self
  329.     {
  330.         $this->amm = $amm;
  332.         return $this;
  333.     }
  335.     public function getCg(): ?string
  336.     {
  337.         return $this->cg;
  338.     }
  340.     public function setCg(?string $cg): self
  341.     {
  342.         $this->cg = $cg;
  344.         return $this;
  345.     }
  347.     public function getDisponibilite(): ?string
  348.     {
  349.         return $this->disponibilite;
  350.     }
  352.     public function setDisponibilite(?string $disponibilite): self
  353.     {
  354.         $this->disponibilite = $disponibilite;
  356.         return $this;
  357.     }
  359.     public function getCategory(): ?Category
  360.     {
  361.         return $this->category;
  362.     }
  364.     public function setCategory(?Category $category): self
  365.     {
  366.         $this->category = $category;
  368.         return $this;
  369.     }
  372.     public function getSpecialite(): ?Speciality
  373.     {
  374.         return $this->specialite;
  375.     }
  377.     public function setSpecialite(?Speciality $specialite): self
  378.     {
  379.         $this->specialite = $specialite;
  381.         return $this;
  382.     }
  384.     /**
  385.      * @return Collection<int, PropositionDetails>
  386.      */
  387.     public function getPropositionDetails(): Collection
  388.     {
  389.         return $this->propositionDetails;
  390.     }
  392.     public function addPropositionDetail(PropositionDetails $propositionDetail): self
  393.     {
  394.         if (!$this->propositionDetails->contains($propositionDetail)) {
  395.             $this->propositionDetails[] = $propositionDetail;
  396.             $propositionDetail->setProduct($this);
  397.         }
  399.         return $this;
  400.     }
  402.     public function removePropositionDetail(PropositionDetails $propositionDetail): self
  403.     {
  404.         if ($this->propositionDetails->removeElement($propositionDetail)) {
  405.             // set the owning side to null (unless already changed)
  406.             if ($propositionDetail->getProduct() === $this) {
  407.                 $propositionDetail->setProduct(null);
  408.             }
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.      * @return Collection<int, OrderDetails>
  416.      */
  417.     public function getOrderDetails(): Collection
  418.     {
  419.         return $this->orderDetails;
  420.     }
  422.     public function addOrderDetail(OrderDetails $orderDetail): self
  423.     {
  424.         if (!$this->orderDetails->contains($orderDetail)) {
  425.             $this->orderDetails[] = $orderDetail;
  426.             $orderDetail->setProductId($this);
  427.         }
  429.         return $this;
  430.     }
  432.     public function removeOrderDetail(OrderDetails $orderDetail): self
  433.     {
  434.         if ($this->orderDetails->removeElement($orderDetail)) {
  435.             // set the owning side to null (unless already changed)
  436.             if ($orderDetail->getProductId() === $this) {
  437.                 $orderDetail->setProductId(null);
  438.             }
  439.         }
  441.         return $this;
  442.     }
  444.     public function getColisageType(): ?ColisageType
  445.     {
  446.         return $this->colisageType;
  447.     }
  449.     public function setColisageType(?ColisageType $colisageType): self
  450.     {
  451.         $this->colisageType = $colisageType;
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection<int, Cart>
  458.      */
  459.     public function getCarts(): Collection
  460.     {
  461.         return $this->carts;
  462.     }
  464.     public function addCart(Cart $cart): self
  465.     {
  466.         if (!$this->carts->contains($cart)) {
  467.             $this->carts[] = $cart;
  468.             $cart->setProduit($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeCart(Cart $cart): self
  475.     {
  476.         if ($this->carts->removeElement($cart)) {
  477.             // set the owning side to null (unless already changed)
  478.             if ($cart->getProduit() === $this) {
  479.                 $cart->setProduit(null);
  480.             }
  481.         }
  483.         return $this;
  484.     }
  486.     public function getPays(): ?string
  487.     {
  488.         return $this->pays;
  489.     }
  491.     public function setPays(?string $pays): self
  492.     {
  493.         $this->pays = $pays;
  495.         return $this;
  496.     }
  498.     public function getDeclinaisonform(): ?DeclinaisonForm
  499.     {
  500.         return $this->declinaisonform;
  501.     }
  503.     public function setDeclinaisonform(?DeclinaisonForm $declinaisonform): self
  504.     {
  505.         $this->declinaisonform = $declinaisonform;
  507.         return $this;
  508.     }
  510.     public function getPrevisionarrivage(): ?int
  511.     {
  512.         return $this->previsionarrivage;
  513.     }
  515.     public function setPrevisionarrivage(?int $previsionarrivage): self
  516.     {
  517.         $this->previsionarrivage = $previsionarrivage;
  519.         return $this;
  520.     }
  522.     public function getPayslocalisation(): ?Pays
  523.     {
  524.         return $this->payslocalisation;
  525.     }
  527.     public function setPayslocalisation(?Pays $payslocalisation): self
  528.     {
  529.         $this->payslocalisation = $payslocalisation;
  531.         return $this;
  532.     }
  534.     public function getLaboratoire(): ?Laboratoire
  535.     {
  536.         return $this->laboratoire;
  537.     }
  539.     public function setLaboratoire(?Laboratoire $laboratoire): self
  540.     {
  541.         $this->laboratoire = $laboratoire;
  543.         return $this;
  544.     }
  546.     public function getIndication(): ?string
  547.     {
  548.         return $this->indication;
  549.     }
  551.     public function setIndication(?string $indication): self
  552.     {
  553.         $this->indication = $indication;
  555.         return $this;
  556.     }
  558.     /**
  559.      * @return Collection<int, ForecastDetails>
  560.      */
  561.     public function getForecastDetails(): Collection
  562.     {
  563.         return $this->forecastDetails;
  564.     }
  566.     public function addForecastDetail(ForecastDetails $forecastDetail): self
  567.     {
  568.         if (!$this->forecastDetails->contains($forecastDetail)) {
  569.             $this->forecastDetails[] = $forecastDetail;
  570.             $forecastDetail->setProduitId($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeForecastDetail(ForecastDetails $forecastDetail): self
  577.     {
  578.         if ($this->forecastDetails->removeElement($forecastDetail)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($forecastDetail->getProduitId() === $this) {
  581.                 $forecastDetail->setProduitId(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     /**
  589.      * @return Collection<int, Photo>
  590.      */
  591.     public function getPhotos(): Collection
  592.     {
  593.         return $this->photos;
  594.     }
  596.     public function addPhoto(Photo $photo): self
  597.     {
  598.         if (!$this->photos->contains($photo)) {
  599.             $this->photos[] = $photo;
  600.             $photo->setProduit($this);
  601.         }
  603.         return $this;
  604.     }
  606.     public function removePhoto(Photo $photo): self
  607.     {
  608.         if ($this->photos->removeElement($photo)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($photo->getProduit() === $this) {
  611.                 $photo->setProduit(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     /**
  619.      * @return Collection<int, Stockpharmacie>
  620.      */
  621.     public function getStockpharmacies(): Collection
  622.     {
  623.         return $this->stockpharmacies;
  624.     }
  626.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  627.     {
  628.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  629.             $this->stockpharmacies[] = $stockpharmacy;
  630.             $stockpharmacy->setProduit($this);
  631.         }
  633.         return $this;
  634.     }
  636.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  637.     {
  638.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  639.             // set the owning side to null (unless already changed)
  640.             if ($stockpharmacy->getProduit() === $this) {
  641.                 $stockpharmacy->setProduit(null);
  642.             }
  643.         }
  645.         return $this;
  646.     }
  648.     public function getPosologie(): ?string
  649.     {
  650.         return $this->posologie;
  651.     }
  653.     public function setPosologie(?string $posologie): self
  654.     {
  655.         $this->posologie = $posologie;
  657.         return $this;
  658.     }
  660.     public function getCreatedAt(): ?\DateTimeInterface
  661.     {
  662.         return $this->createdAt;
  663.     }
  665.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  666.     {
  667.         $this->createdAt = $createdAt;
  669.         return $this;
  670.     }
  672.     public function isIsStockPharmacie(): ?bool
  673.     {
  674.         return $this->isStockPharmacie;
  675.     }
  677.     public function setIsStockPharmacie(?bool $isStockPharmacie): self
  678.     {
  679.         $this->isStockPharmacie = $isStockPharmacie;
  681.         return $this;
  682.     }
  684.     public function isIsOrdonnance(): ?bool
  685.     {
  686.         return $this->isOrdonnance;
  687.     }
  689.     public function setIsOrdonnance(?bool $isOrdonnance): self
  690.     {
  691.         $this->isOrdonnance = $isOrdonnance;
  693.         return $this;
  694.     }
  696.     public function isIsPhotoNotFound(): ?bool
  697.     {
  698.         return $this->isPhotoNotFound;
  699.     }
  701.     public function setIsPhotoNotFound(?bool $isPhotoNotFound): self
  702.     {
  703.         $this->isPhotoNotFound = $isPhotoNotFound;
  705.         return $this;
  706.     }
  708.     public function isIsDoublon(): ?bool
  709.     {
  710.         return $this->isDoublon;
  711.     }
  713.     public function setIsDoublon(?bool $isDoublon): self
  714.     {
  715.         $this->isDoublon = $isDoublon;
  717.         return $this;
  718.     }
  720.     /**
  721.      * @return Collection<int, SearchHistory>
  722.      */
  723.     public function getSearchHistories(): Collection
  724.     {
  725.         return $this->searchHistories;
  726.     }
  728.     public function addSearchHistory(SearchHistory $searchHistory): self
  729.     {
  730.         if (!$this->searchHistories->contains($searchHistory)) {
  731.             $this->searchHistories[] = $searchHistory;
  732.             $searchHistory->setClickAfter($this);
  733.         }
  735.         return $this;
  736.     }
  738.     public function removeSearchHistory(SearchHistory $searchHistory): self
  739.     {
  740.         if ($this->searchHistories->removeElement($searchHistory)) {
  741.             // set the owning side to null (unless already changed)
  742.             if ($searchHistory->getClickAfter() === $this) {
  743.                 $searchHistory->setClickAfter(null);
  744.             }
  745.         }
  747.         return $this;
  748.     }
  749. }