src/Entity/Produit.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProduitRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use JsonSerializable;
  10. use Symfony\Component\Serializer\Annotation\Groups;
  12. /**
  13.  * @ORM\Entity(repositoryClass=ProduitRepository::class)
  14.  */
  15. class Produit implements JsonSerializable
  16. {
  17.     /**
  18.      * @ORM\Id
  19.      * @ORM\GeneratedValue
  20.      * @ORM\Column(type="integer")
  21.      */
  22.     private $id;
  24.     private $isNew = false;
  26.     private $stock = 0;
  28.     /**
  29.      * @ORM\Column(type="string", length=255)
  30.      */
  31.     private $reference;
  33.     /**
  34.      * @ORM\Column(type="string", length=255)
  35.      */
  36.     private $name;
  37.     /**
  38.      *
  39.      * @ORM\Column(type="text", nullable=true)
  40.      */
  41.     private $description;
  43.     /**
  44.      * @ORM\Column(type="integer")
  45.      */
  46.     private $usual_quantity;
  48.     /**
  49.      * @ORM\Column(type="float")
  50.      */
  51.     private $buying_price;
  52.     /**
  53.      *
  54.      * @ORM\Column(type="float")
  55.      */
  56.     private $price_ht;
  57.     /**
  58.      *
  59.      * @ORM\Column(type="float")
  60.      */
  61.     private $price_ttc;
  62.     /**
  63.      * @ORM\ManyToOne(targetEntity=Category::class, inversedBy="produits")
  64.      */
  65.     private $categories;
  66.     /**
  67.      * @ORM\ManyToOne(targetEntity=Tva::class, inversedBy="produits")
  68.      */
  69.     private $tva;
  70.     /**
  71.      * @ORM\ManyToMany(targetEntity=Tag::class, inversedBy="produits")
  72.      */
  73.     private $tags;
  74.     /**
  75.      * @ORM\Column(type="string", length=255)
  76.      */
  77.     private $unit;
  78.     /**
  79.      * @ORM\Column(type="boolean")
  80.      */
  81.     private $isStock;
  83.     /**
  84.      * @ORM\Column(type="boolean")
  85.      */
  86.     private $isDeclination;
  87.     /**
  88.      * @ORM\Column(type="datetime")
  89.      */
  90.     private $createdAt;
  92.     /**
  93.      * @ORM\ManyToMany(targetEntity=Declination::class, mappedBy="Produits")
  94.      */
  95.     private $declinations;
  96.     /**
  97.      * @ORM\OneToMany(targetEntity=ProduitDeclinationValue::class, mappedBy="produit", orphanRemoval=true)
  98.      */
  99.     private $produitDeclinationValues;
  100.     /**
  101.      *
  102.      * @ORM\ManyToMany(targetEntity=File::class, cascade={"persist"})
  103.      */
  104.     private $picture;
  107.     public $image;
  109.     /**
  110.      * @ORM\OneToMany(targetEntity=DocumentProduit::class, mappedBy="produit")
  111.      */
  112.     private $documentProduits;
  113.     /**
  114.      * @ORM\OneToMany(targetEntity=Stock::class, mappedBy="produit")
  115.      */
  116.     private $stocks;
  117.     /**
  118.      * @ORM\Column(type="integer", nullable=true)
  119.      */
  120.     private $uuid;
  121.     /**
  122.      * @ORM\ManyToOne(targetEntity=Promotion::class, inversedBy="produits")
  123.      */
  124.     private $promotion;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=Activity::class, mappedBy="produit")
  127.      */
  128.     private $activities;
  129.     /**
  130.      * @ORM\Column(type="text", nullable=true)
  131.      */
  132.     private $information;
  133.     /**
  134.      * @ORM\Column(type="boolean", nullable=true)
  135.      */
  136.     private $isArchived;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="produit")
  139.      */
  140.     private $comments;
  141. //    /**
  142. //     * @ORM\ManyToOne(targetEntity=Category::class, inversedBy="produitsCategory")
  143. //     */
  144. //    private $principalCategory;
  145.     /**
  146.      * @ORM\Column(type="datetime", nullable=true)
  147.      */
  148.     private $deletedAt;
  149.     /**
  150.      * @ORM\Column(type="text", nullable=true)
  151.      */
  152.     private $reasonOfDelete;
  154.     public function __construct()
  155.     {
  156.         $this->tags = new ArrayCollection();
  157.         $this->declinations = new ArrayCollection();
  158.         $this->produitDeclinationValues = new ArrayCollection();
  159.         $this->picture = new ArrayCollection();
  160.         $this->documentProduits = new ArrayCollection();
  161.         $this->stocks = new ArrayCollection();
  162.         $this->activities = new ArrayCollection();
  163.         $this->comments = new ArrayCollection();
  164.     }
  166.     public function getImage(): ?string
  167.     {
  168.         return $this->image;
  169.     }
  171.     public function getId(): ?int
  172.     {
  173.         return $this->id;
  174.     }
  176.     public function getReference(): ?string
  177.     {
  178.         return $this->reference;
  179.     }
  181.     public function setReference(string $reference): self
  182.     {
  183.         $this->reference = $reference;
  185.         return $this;
  186.     }
  188.     public function getName(): ?string
  189.     {
  190.         return $this->name;
  191.     }
  193.     public function setName(string $name): self
  194.     {
  195.         $this->name = $name;
  197.         return $this;
  198.     }
  200.     public function getDescription(): ?string
  201.     {
  202.         return $this->description;
  203.     }
  205.     public function setDescription(?string $description): self
  206.     {
  207.         $this->description = $description;
  209.         return $this;
  210.     }
  212.     public function getUsualQuantity(): ?int
  213.     {
  214.         return $this->usual_quantity;
  215.     }
  217.     public function setUsualQuantity(int $usual_quantity): self
  218.     {
  219.         $this->usual_quantity = $usual_quantity;
  221.         return $this;
  222.     }
  224.     public function getBuyingPrice(): ?float
  225.     {
  226.         return $this->buying_price;
  227.     }
  229.     public function setBuyingPrice(float $buying_price): self
  230.     {
  231.         $this->buying_price = $buying_price;
  233.         return $this;
  234.     }
  236.     public function getPriceHt(): ?float
  237.     {
  238.         return (float) $this->price_ht;
  239.     }
  241.     public function setPriceHt(float $price_ht): self
  242.     {
  243.         $this->price_ht = $price_ht;
  245.         return $this;
  246.     }
  248.     public function getPriceTtc(): ?float
  249.     {
  250.         return $this->price_ttc;
  251.     }
  253.     public function setPriceTtc(float $price_ttc): self
  254.     {
  255.         $this->price_ttc = $price_ttc;
  257.         return $this;
  258.     }
  260.     public function getCategories(): ?Category
  261.     {
  262.         return $this->categories;
  263.     }
  265.     public function setCategories(?Category $categories): self
  266.     {
  267.         $this->categories = $categories;
  269.         return $this;
  270.     }
  272.     public function getTva(): ?Tva
  273.     {
  274.         return $this->tva;
  275.     }
  277.     public function setTva(?Tva $tva): self
  278.     {
  279.         $this->tva = $tva;
  281.         return $this;
  282.     }
  284.     /**
  285.      * @return Collection|Tag[]
  286.      */
  287.     public function getTags(): Collection
  288.     {
  289.         return $this->tags;
  290.     }
  292.     public function addTag(Tag $tag): self
  293.     {
  294.         if (!$this->tags->contains($tag)) {
  295.             $this->tags[] = $tag;
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeTag(Tag $tag): self
  302.     {
  303.         $this->tags->removeElement($tag);
  305.         return $this;
  306.     }
  308.     public function getUnit(): ?string
  309.     {
  310.         return $this->unit;
  311.     }
  313.     public function setUnit(string $unit): self
  314.     {
  315.         $this->unit = $unit;
  317.         return $this;
  318.     }
  320.     public function getIsStock(): ?bool
  321.     {
  322.         return $this->isStock;
  323.     }
  325.     public function setIsStock(bool $isStock): self
  326.     {
  327.         $this->isStock = $isStock;
  329.         return $this;
  330.     }
  332.     public function getIsDeclination(): ?bool
  333.     {
  334.         return $this->isDeclination;
  335.     }
  337.     public function setIsDeclination(bool $isDeclination): self
  338.     {
  339.         $this->isDeclination = $isDeclination;
  341.         return $this;
  342.     }
  344.     public function getCreatedAt(): ?\DateTimeInterface
  345.     {
  346.         return $this->createdAt;
  347.     }
  349.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  350.     {
  351.         $this->createdAt = $createdAt;
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection|Declination[]
  358.      */
  359.     public function getDeclinations(): Collection
  360.     {
  361.         return $this->declinations;
  362.     }
  364.     public function addDeclination(Declination $declination): self
  365.     {
  366.         if (!$this->declinations->contains($declination)) {
  367.             $this->declinations[] = $declination;
  368.             $declination->addProduit($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeDeclination(Declination $declination): self
  375.     {
  376.         if ($this->declinations->removeElement($declination)) {
  377.             $declination->removeProduit($this);
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.      * @return Collection|ProduitDeclinationValue[]
  385.      */
  386.     public function getProduitDeclinationValues(): Collection
  387.     {
  388.         return $this->produitDeclinationValues;
  389.     }
  391.     public function addProduitDeclinationValue(ProduitDeclinationValue $produitDeclinationValue): self
  392.     {
  393.         if (!$this->produitDeclinationValues->contains($produitDeclinationValue)) {
  394.             $this->produitDeclinationValues[] = $produitDeclinationValue;
  395.             $produitDeclinationValue->setProduit($this);
  396.         }
  398.         return $this;
  399.     }
  401.     public function removeProduitDeclinationValue(ProduitDeclinationValue $produitDeclinationValue): self
  402.     {
  403.         if ($this->produitDeclinationValues->removeElement($produitDeclinationValue)) {
  404.             // set the owning side to null (unless already changed)
  405.             if ($produitDeclinationValue->getProduit() === $this) {
  406.                 $produitDeclinationValue->setProduit(null);
  407.             }
  408.         }
  410.         return $this;
  411.     }
  413.     /**
  414.      * @return Collection|File[]
  415.      */
  416.     public function getPicture(): Collection
  417.     {
  418.         return $this->picture;
  419.     }
  421.     public function addPicture(File $picture): self
  422.     {
  423.         if (!$this->picture->contains($picture))
  424.             $this->picture[] = $picture;
  426.         return $this;
  427.     }
  429.     public function removePicture(File $picture): self
  430.     {
  431.         $this->picture->removeElement($picture);
  433.         return $this;
  434.     }
  436.     /**
  437.      * @return Collection|DocumentProduit[]
  438.      */
  439.     public function getDocumentProduits(): Collection
  440.     {
  441.         return $this->documentProduits;
  442.     }
  444.     public function addDocumentProduit(DocumentProduit $documentProduit): self
  445.     {
  446.         if (!$this->documentProduits->contains($documentProduit)) {
  447.             $this->documentProduits[] = $documentProduit;
  448.             $documentProduit->setProduit($this);
  449.         }
  451.         return $this;
  452.     }
  454.     public function removeDocumentProduit(DocumentProduit $documentProduit): self
  455.     {
  456.         if ($this->documentProduits->removeElement($documentProduit))
  457.             // set the owning side to null (unless already changed)
  458.             if ($documentProduit->getProduit() === $this)
  459.                 $documentProduit->setProduit(null);
  461.         return $this;
  462.     }
  464.     /**
  465.      * @return Collection|Stock[]
  466.      */
  467.     public function getStocks(): Collection
  468.     {
  469.         return $this->stocks;
  470.     }
  472.     public function addStock(Stock $stock): self
  473.     {
  474.         if (!$this->stocks->contains($stock)) {
  475.             $this->stocks[] = $stock;
  476.             $stock->setProduit($this);
  477.         }
  479.         return $this;
  480.     }
  482.     public function removeStock(Stock $stock): self
  483.     {
  484.         if ($this->stocks->removeElement($stock))
  485.             // set the owning side to null (unless already changed)
  486.             if ($stock->getProduit() === $this)
  487.                 $stock->setProduit(null);
  489.         return $this;
  490.     }
  492.     public function getUuid(): ?int
  493.     {
  494.         return $this->uuid;
  495.     }
  497.     public function setUuid(?int $uuid): self
  498.     {
  499.         $this->uuid = $uuid;
  501.         return $this;
  502.     }
  504.     public function getPromotion(): ?Promotion
  505.     {
  506.         return $this->promotion;
  507.     }
  509.     public function setPromotion(?Promotion $promotion): self
  510.     {
  511.         $this->promotion = $promotion;
  512.         return $this;
  513.     }
  515.     /**
  516.      * @return Collection|Activity[]
  517.      */
  518.     public function getActivities(): Collection
  519.     {
  520.         return $this->activities;
  521.     }
  523.     public function addActivity(Activity $activity): self
  524.     {
  525.         if (!$this->activities->contains($activity)) {
  526.             $this->activities[] = $activity;
  527.             $activity->setProduit($this);
  528.         }
  530.         return $this;
  531.     }
  533.     public function removeActivity(Activity $activity): self
  534.     {
  535.         if ($this->activities->removeElement($activity))
  536.             // set the owning side to null (unless already changed)
  537.             if ($activity->getProduit() === $this)
  538.                 $activity->setProduit(null);
  540.         return $this;
  541.     }
  543.     public function getInformation(): ?string
  544.     {
  545.         return $this->information;
  546.     }
  548.     public function setInformation(?string $information): self
  549.     {
  550.         $this->information = $information;
  552.         return $this;
  553.     }
  555.     public function getIsArchived(): ?bool
  556.     {
  557.         return $this->isArchived;
  558.     }
  560.     public function setIsArchived(?bool $isArchived): self
  561.     {
  562.         $this->isArchived = $isArchived;
  564.         return $this;
  565.     }
  567.     /**
  568.      * @return Collection|Comment[]
  569.      */
  570.     public function getComments(): Collection
  571.     {
  572.         return $this->comments;
  573.     }
  575.     public function addComment(Comment $comment): self
  576.     {
  577.         if (!$this->comments->contains($comment)) {
  578.             $this->comments[] = $comment;
  579.             $comment->setProduit($this);
  580.         }
  581.         return $this;
  582.     }
  584.     public function removeComment(Comment $comment): self
  585.     {
  586.         if ($this->comments->removeElement($comment))
  587.             // set the owning side to null (unless already changed)
  588.             if ($comment->getProduit() === $this)
  589.                 $comment->setProduit(null);
  590.         return $this;
  591.     }
  593.     public function getIsNew(): ?bool
  594.     {
  595.         return $this->isNew;
  596.     }
  598.     public function setIsNew(bool $isNew): self
  599.     {
  600.         $this->isNew = $isNew;
  602.         return $this;
  603.     }
  605.     public function getStock(): ?int
  606.     {
  607.         foreach ($this->getStocks() as $stock) {
  608.             $this->stock += $stock->getQtAvailable() - $stock->getQtReserved();
  609.         }
  611.         return $this->stock;
  612.     }
  614.     public function setStock($stock): self
  615.     {
  616.         $this->stock = $stock;
  618.         return $this;
  619.     }
  621.     public function isNew()
  622.     {
  623.         // On va chercher les produit nouveau dont la date de création ne dépasse pas 90 jours
  624.         $date = new \DateTime('now');
  625.         $date->modify('-90 day');
  627.         if ($this->getCreatedAt() >= $date) {
  628.             $this->setIsNew(true);
  629.         }
  630.         return $this->isNew;
  631.     }
  633.     public function jsonSerialize()
  634.     {
  635.         $tabPictures = [];
  637.         foreach ($this->getPicture() as $picture) {
  638.             array_push($tabPictures, $picture->getImageName());
  639.         }
  641.         return array(
  642.             'id' => $this->getId(),
  643.             'name' => $this->getName(),
  644.             'description' => $this->getDescription(),
  645.             'picture' => $tabPictures,
  646.             'image' => $this->getImage(),
  647.             'priceHT' => $this->getPriceHt(),
  648.             'priceTTC' => $this->getPriceTtc(),
  649.             'category' => $this->getCategories() ? $this->getCategories()->getId() : 0,
  650.             //'produitDeclinationValues' => $this->getProduitDeclinationValues()->toArray(),
  651.             'promo' => $this->getPromotion(),
  652.             'isNew' => $this->isNew(),
  653.             'stock' => $this->getStock(),
  654.             //'tags' => $this->getTags()->toArray(),
  655.         );
  656.     }
  658.     public function getPrincipalCategory(): ?Category
  659.     {
  660.         return $this->principalCategory;
  661.     }
  663.     public function setPrincipalCategory(?Category $principalCategory): self
  664.     {
  665.         $this->principalCategory = $principalCategory;
  667.         return $this;
  668.     }
  670.     public function getDeletedAt(): ?\DateTimeInterface
  671.     {
  672.         return $this->deletedAt;
  673.     }
  675.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  676.     {
  677.         $this->deletedAt = $deletedAt;
  679.         return $this;
  680.     }
  681.     public function getReasonOfDelete(): ?string
  682.     {
  683.         return $this->reasonOfDelete;
  684.     }
  686.     public function setReasonOfDelete(?string $reasonOfDelete): self
  687.     {
  688.         $this->reasonOfDelete = $reasonOfDelete;
  690.         return $this;
  691.     }
  692. }