src/Entity/Product.php line 232

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 $title; 
  27.     /**
  28.      * @ORM\Column(type="decimal", precision=10, scale=2)
  29.      */
  30.     private $priceHt = 0.00; // default value
  32.     /**
  33.      * @ORM\Column(type="integer")
  34.      */
  35.     private $stock;
  37.     /**
  38.      * @ORM\Column(type="text")
  39.      */
  40.     private $desctription;
  42.     /**
  43.      * @ORM\Column(type="string", length=255)
  44.      */
  45.     private $picture;
  47.     /**
  48.      * @ORM\Column(type="string", length=255, nullable=true)
  49.      */
  50.     private $linkspictures;
  52.     /**
  53.      * @ORM\ManyToOne(targetEntity=UserPlatform::class)
  54.      * @ORM\JoinColumn(nullable=false)
  55.      */
  56.     private $userAdd;
  58.     /**
  59.      * @ORM\ManyToOne(targetEntity=CategoriProduct::class)
  60.      * @ORM\JoinColumn(nullable=false)
  61.      */
  62.     private $fkcategorie;
  64.     /**
  65.      * @ORM\ManyToOne(targetEntity=SousCategorie::class)
  66.      */
  67.     private $fksousCategorie;
  69.     /**
  70.      * @ORM\ManyToOne(targetEntity=Devise::class)
  71.      */
  72.     private $fkdevise;
  74.     /**
  75.      * @ORM\ManyToOne(targetEntity=Shop::class)
  76.      */
  77.     private $shop;
  79.     /**
  80.      * @ORM\OneToMany(targetEntity=PriceProduct::class, mappedBy="product")
  81.      */
  82.     private $priceProducts;
  84.     /**
  85.      * @ORM\Column(type="integer")
  86.      */
  87.     private $statdispo;
  89.     /**
  90.      * @ORM\Column(type="integer")
  91.      */
  92.     private $stateval = 1;
  94.     /**
  95.      * @ORM\Column(type="integer")
  96.      */
  97.     private $statetype;
  99.     /**
  100.      * @ORM\Column(type="json", nullable=true)
  101.      */
  102.     private ?array $statetypes = null;
  104.     /**
  105.      * @ORM\Column(type="integer")
  106.      */
  107.     private $points;
  109.     /**
  110.      * @ORM\Column(type="integer")
  111.      */
  112.     private int $searchCount = 0;
  114.     /**
  115.      * @ORM\OneToMany(targetEntity=Stock::class, mappedBy="produit")
  116.      */
  117.     private $stocks;
  119.     /**
  120.      * @ORM\Column(type="text", nullable=true)
  121.      */
  122.     private $keyWord;
  124.     /**
  125.      * @ORM\Column(type="json", nullable=true)
  126.      */
  127.     private ?array $modules = [];
  129.     /**
  130.      * @ORM\Column(type="boolean")
  131.      */
  132.     private bool $enabled = true;
  134.     /**
  135.      * @ORM\OneToMany(targetEntity=Location::class, mappedBy="product")
  136.      */
  137.     private $locations;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=FreelanceStock::class, mappedBy="produit")
  141.      */
  142.     private $freelanceStocks;
  144.     /**
  145.      * @ORM\OneToMany(targetEntity=HistoriqueTransactionFreelance::class, mappedBy="produit")
  146.      */
  147.     private $historiqueTransactions;
  150.     public function __construct()
  151.     {
  152.         $this->priceProducts = new ArrayCollection();
  153.         $this->stocks = new ArrayCollection();
  154.         $this->locations = new ArrayCollection();
  155.         $this->freelanceStocks = new ArrayCollection();
  156.         $this->historiqueTransactions = new ArrayCollection();
  157.     }
  159.     public function getId(): ?int
  160.     {
  161.         return $this->id;
  162.     }
  164.     public function getTitle(): ?string
  165.     {
  166.         return $this->title;
  167.     }
  169.     public function setTitle(string $title): self
  170.     {
  171.         $this->title = $title;
  173.         return $this;
  174.     }
  176.     public function getPriceHt(): ?string
  177.     {
  178.         return $this->priceHt;
  179.     }
  181.     public function setPriceHt(string $priceHt): self
  182.     {
  183.         $this->priceHt = $priceHt;
  185.         return $this;
  186.     }
  188.     public function getStock(): ?int
  189.     {
  190.         return $this->stock;
  191.     }
  193.     public function setStock(int $stock): self
  194.     {
  195.         $this->stock = $stock;
  197.         return $this;
  198.     }
  200.     public function getDesctription(): ?string
  201.     {
  202.         return $this->desctription;
  203.     }
  205.     public function setDesctription(string $desctription): self
  206.     {
  207.         $this->desctription = $desctription;
  209.         return $this;
  210.     }
  212.     public function getPicture(): ?string
  213.     {
  214.         return $this->picture;
  215.     }
  217.     public function setPicture(string $picture): self
  218.     {
  219.         $this->picture = $picture;
  221.         return $this;
  222.     }
  224.     public function getLinkspictures(): ?string
  225.     {
  226.         return $this->linkspictures;
  227.     }
  228.     
  229.     public function getLinkspicturesArrays(): ?array
  230.                    {
  231.                        $typevalue = gettype(json_decode($this->linkspictures));
  232.                         if(gettype(json_decode($this->linkspictures)) == "array"){
  233.                              return json_decode($this->linkspictures);
  234.                         } else return null;
  235.                    }
  237.     public function setLinkspictures(?string $linkspictures): self
  238.     {
  239.         $this->linkspictures = $linkspictures;
  241.         return $this;
  242.     }
  244.     public function getUserAdd(): ?UserPlatform
  245.     {
  246.         return $this->userAdd;
  247.     }
  249.     public function setUserAdd(?UserPlatform $userAdd): self
  250.     {
  251.         $this->userAdd = $userAdd;
  253.         return $this;
  254.     }
  256.     public function getFkcategorie(): ?CategoriProduct
  257.     {
  258.         return $this->fkcategorie;
  259.     }
  261.     public function setFkcategorie(?CategoriProduct $fkcategorie): self
  262.     {
  263.         $this->fkcategorie = $fkcategorie;
  265.         return $this;
  266.     }
  268.     public function getFksousCategorie(): ?SousCategorie
  269.     {
  270.         return $this->fksousCategorie;
  271.     }
  273.     public function setFksousCategorie(?SousCategorie $fksousCategorie): self
  274.     {
  275.         $this->fksousCategorie = $fksousCategorie;
  277.         return $this;
  278.     }
  280.     public function getFkdevise(): ?Devise
  281.     {
  282.         return $this->fkdevise;
  283.     }
  285.     public function setFkdevise(?Devise $fkdevise): self
  286.     {
  287.         $this->fkdevise = $fkdevise;
  289.         return $this;
  290.     }
  292.     public function getShop(): ?Shop
  293.     {
  294.         return $this->shop;
  295.     }
  297.     public function setShop(?Shop $shop): self
  298.     {
  299.         $this->shop = $shop;
  301.         return $this;
  302.     }
  304.     /**
  305.      * @return Collection<int, PriceProduct>
  306.      */
  307.     public function getPriceProducts(): Collection
  308.     {
  309.         return $this->priceProducts;
  310.     }
  312.     public function addPriceProduct(PriceProduct $priceProduct): self
  313.     {
  314.         if (!$this->priceProducts->contains($priceProduct)) {
  315.             $this->priceProducts[] = $priceProduct;
  316.             $priceProduct->setProduct($this);
  317.         }
  319.         return $this;
  320.     }
  322.     public function removePriceProduct(PriceProduct $priceProduct): self
  323.     {
  324.         if ($this->priceProducts->removeElement($priceProduct)) {
  325.             // set the owning side to null (unless already changed)
  326.             if ($priceProduct->getProduct() === $this) {
  327.                 $priceProduct->setProduct(null);
  328.             }
  329.         }
  331.         return $this;
  332.     }
  334.     public function getStatdispo(): ?int
  335.     {
  336.         return $this->statdispo;
  337.     }
  339.     public function setStatdispo(int $statdispo): self
  340.     {
  341.         $this->statdispo = $statdispo;
  343.         return $this;
  344.     }
  346.     public function getStateval(): ?int
  347.     {
  348.         return $this->stateval;
  349.     }
  351.     public function setStateval(int $stateval): self
  352.     {
  353.         $this->stateval = $stateval;
  355.         return $this;
  356.     }
  358.     public function getStatetype(): ?int
  359.     {
  360.         return $this->statetype;
  361.     }
  363.     public function setStatetype(int $statetype): self
  364.     {
  365.         $this->statetype = $statetype;
  367.         return $this;
  368.     }
  370.     /**
  371.      * @return int[]
  372.      */
  373.     public function getStatetypes(): array
  374.     {
  375.         if (!empty($this->statetypes)) {
  376.             return array_map('intval', $this->statetypes);
  377.         }
  379.         return $this->statetype !== null ? [(int) $this->statetype] : [0];
  380.     }
  382.     /**
  383.      * @param int[]|null $statetypes
  384.      */
  385.     public function setStatetypes(?array $statetypes): self
  386.     {
  387.         $statetypes = array_values(array_unique(array_map('intval', $statetypes ?? [])));
  388.         $this->statetypes = $statetypes ?: [0];
  389.         // Compatibilité avec les anciens traitements qui utilisent encore statetype.
  390.         $this->statetype = in_array(0, $this->statetypes, true) ? 0 : 1;
  392.         return $this;
  393.     }
  395.     /**
  396.      * @return string[]
  397.      */
  398.     public function getStatetypeLabels(): array
  399.     {
  400.         $labels = [];
  401.         foreach ($this->getStatetypes() as $statetype) {
  402.             if ($statetype === 0) {
  403.                 $labels[] = 'Abonnement';
  404.             } elseif ($statetype === 1) {
  405.                 $labels[] = 'Achat licence';
  406.             }
  407.         }
  409.         return $labels;
  410.     }
  411.     
  413.     public function getPoints(): ?int
  414.     {
  415.         return $this->points;
  416.     }
  418.     public function setPoints(int $points): self
  419.     {
  420.         $this->points = $points;
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, Stock>
  427.      */
  428.     public function getStocks(): Collection
  429.     {
  430.         return $this->stocks;
  431.     }
  433.     public function addStock(Stock $stock): self
  434.     {
  435.         if (!$this->stocks->contains($stock)) {
  436.             $this->stocks[] = $stock;
  437.             $stock->setProduit($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeStock(Stock $stock): self
  444.     {
  445.         if ($this->stocks->removeElement($stock)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($stock->getProduit() === $this) {
  448.                 $stock->setProduit(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     public function getKeyWord(): ?string
  456.     {
  457.         return $this->keyWord;
  458.     }
  460.     public function setKeyWord(?string $keyWord): self
  461.     {
  462.         $this->keyWord = $keyWord;
  464.         return $this;
  465.     }
  467.     /**
  468.      * @return string[]
  469.      */
  470.     public function getModules(): array
  471.     {
  472.         return !empty($this->modules) ? $this->modules : [''];
  473.     }
  475.     /**
  476.      * @param string[]|null $modules
  477.      */
  478.     public function setModules(?array $modules): self
  479.     {
  480.         $this->modules = array_values(array_filter($modules ?? [], static function ($module): bool {
  481.             return trim((string) $module) !== '';
  482.         }));
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return string[]
  489.      */
  490.     public function getModulesForDisplay(): array
  491.     {
  492.         return array_values(array_filter($this->modules ?? [], static function ($module): bool {
  493.             return trim((string) $module) !== '';
  494.         }));
  495.     }
  497.     public function isEnabled(): bool
  498.     {
  499.         return $this->enabled;
  500.     }
  502.     public function setEnabled(bool $enabled): self
  503.     {
  504.         $this->enabled = $enabled;
  505.         return $this;
  506.     }
  508.     /* Statistics*/
  509.     public function getSearchCount(): int
  510.     {
  511.         return $this->searchCount;
  512.     }
  514.     public function setSearchCount(int $searchCount): self
  515.     {
  516.         $this->searchCount = $searchCount;
  518.         return $this;
  519.     }
  521.     public function incrementSearchCount(): self
  522.     {
  523.         $this->searchCount++;
  525.         return $this;
  526.     }
  531.     /**
  532.      * @return Collection<int, Location>
  533.      */
  534.     public function getLocations(): Collection
  535.     {
  536.         return $this->locations;
  537.     }
  539.     public function addLocation(Location $location): self
  540.     {
  541.         if (!$this->locations->contains($location)) {
  542.             $this->locations[] = $location;
  543.             $location->setProduct($this);
  544.         }
  546.         return $this;
  547.     }
  549.     public function removeLocation(Location $location): self
  550.     {
  551.         if ($this->locations->removeElement($location)) {
  552.             // set the owning side to null (unless already changed)
  553.             if ($location->getProduct() === $this) {
  554.                 $location->setProduct(null);
  555.             }
  556.         }
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection<int, FreelanceStock>
  563.      */
  564.     public function getFreelanceStocks(): Collection
  565.     {
  566.         return $this->freelanceStocks;
  567.     }
  569.     public function addFreelanceStock(FreelanceStock $freelanceStock): self
  570.     {
  571.         if (!$this->freelanceStocks->contains($freelanceStock)) {
  572.             $this->freelanceStocks[] = $freelanceStock;
  573.             $freelanceStock->setProduit($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeFreelanceStock(FreelanceStock $freelanceStock): self
  580.     {
  581.         if ($this->freelanceStocks->removeElement($freelanceStock)) {
  582.             if ($freelanceStock->getProduit() === $this) {
  583.                 $freelanceStock->setProduit(null);
  584.             }
  585.         }
  587.         return $this;
  588.     }
  590.     /**
  591.      * @return Collection<int, HistoriqueTransactionFreelance>
  592.      */
  593.     public function getHistoriqueTransactions(): Collection
  594.     {
  595.         return $this->historiqueTransactions;
  596.     }
  598.     public function addHistoriqueTransaction(HistoriqueTransactionFreelance $historiqueTransaction): self
  599.     {
  600.         if (!$this->historiqueTransactions->contains($historiqueTransaction)) {
  601.             $this->historiqueTransactions[] = $historiqueTransaction;
  602.             $historiqueTransaction->setProduit($this);
  603.         }
  605.         return $this;
  606.     }
  608.     public function removeHistoriqueTransaction(HistoriqueTransactionFreelance $historiqueTransaction): self
  609.     {
  610.         if ($this->historiqueTransactions->removeElement($historiqueTransaction)) {
  611.             if ($historiqueTransaction->getProduit() === $this) {
  612.                 $historiqueTransaction->setProduit(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  618. }