src/Entity/Produit.php line 665

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.     /**
  155.      * @ORM\ManyToMany(targetEntity=User::class, inversedBy="produits")
  156.      * @ORM\JoinTable(name="supplier_produit",
  157.      *      joinColumns={@ORM\JoinColumn(name="produit_id", referencedColumnName="id")},
  158.      *      inverseJoinColumns={@ORM\JoinColumn(name="user_id", referencedColumnName="id")}
  159.      * )
  160.      */
  161.     private $users;
  163.     /**
  164.      * @ORM\Column(type="boolean", nullable=true)
  165.      */
  166.     private $bestSelection;
  168.     /**
  169.      * @ORM\Column(type="boolean", options={"default" : true})
  170.      */
  171.     private $showInWebSite;
  173.     public function __construct()
  174.     {
  175.         $this->tags = new ArrayCollection();
  176.         $this->declinations = new ArrayCollection();
  177.         $this->produitDeclinationValues = new ArrayCollection();
  178.         $this->picture = new ArrayCollection();
  179.         $this->documentProduits = new ArrayCollection();
  180.         $this->stocks = new ArrayCollection();
  181.         $this->activities = new ArrayCollection();
  182.         $this->comments = new ArrayCollection();
  183.         $this->users = new ArrayCollection();
  184.     }
  186.     public function getImage(): ?string
  187.     {
  188.         return $this->image;
  189.     }
  191.     public function getId(): ?int
  192.     {
  193.         return $this->id;
  194.     }
  196.     public function getReference(): ?string
  197.     {
  198.         return $this->reference;
  199.     }
  201.     public function setReference(string $reference): self
  202.     {
  203.         $this->reference = $reference;
  205.         return $this;
  206.     }
  208.     public function getName(): ?string
  209.     {
  210.         return $this->name;
  211.     }
  213.     public function setName(string $name): self
  214.     {
  215.         $this->name = $name;
  217.         return $this;
  218.     }
  220.     public function getDescription(): ?string
  221.     {
  222.         return $this->description;
  223.     }
  225.     public function setDescription(?string $description): self
  226.     {
  227.         $this->description = $description;
  229.         return $this;
  230.     }
  232.     public function getUsualQuantity(): ?int
  233.     {
  234.         return $this->usual_quantity;
  235.     }
  237.     public function setUsualQuantity(int $usual_quantity): self
  238.     {
  239.         $this->usual_quantity = $usual_quantity;
  241.         return $this;
  242.     }
  244.     public function getBuyingPrice(): ?float
  245.     {
  246.         return $this->buying_price;
  247.     }
  249.     public function setBuyingPrice(float $buying_price): self
  250.     {
  251.         $this->buying_price = $buying_price;
  253.         return $this;
  254.     }
  256.     public function getPriceHt(): ?float
  257.     {
  258.         return (float) $this->price_ht;
  259.     }
  261.     public function setPriceHt(float $price_ht): self
  262.     {
  263.         $this->price_ht = $price_ht;
  265.         return $this;
  266.     }
  268.     public function getPriceTtc(): ?float
  269.     {
  270.         return $this->price_ttc;
  271.     }
  273.     public function setPriceTtc(float $price_ttc): self
  274.     {
  275.         $this->price_ttc = $price_ttc;
  277.         return $this;
  278.     }
  280.     public function getCategories(): ?Category
  281.     {
  282.         return $this->categories;
  283.     }
  285.     public function setCategories(?Category $categories): self
  286.     {
  287.         $this->categories = $categories;
  289.         return $this;
  290.     }
  292.     public function getTva(): ?Tva
  293.     {
  294.         return $this->tva;
  295.     }
  297.     public function setTva(?Tva $tva): self
  298.     {
  299.         $this->tva = $tva;
  301.         return $this;
  302.     }
  304.     /**
  305.      * @return Collection|Tag[]
  306.      */
  307.     public function getTags(): Collection
  308.     {
  309.         return $this->tags;
  310.     }
  312.     public function addTag(Tag $tag): self
  313.     {
  314.         if( !$this->tags->contains($tag)) {
  315.             $this->tags[] = $tag;
  316.         }
  318.         return $this;
  319.     }
  321.     public function removeTag(Tag $tag): self
  322.     {
  323.         $this->tags->removeElement($tag);
  325.         return $this;
  326.     }
  328.     public function getUnit(): ?string
  329.     {
  330.         return $this->unit;
  331.     }
  333.     public function setUnit(string $unit): self
  334.     {
  335.         $this->unit = $unit;
  337.         return $this;
  338.     }
  340.     public function getIsStock(): ?bool
  341.     {
  342.         return $this->isStock;
  343.     }
  345.     public function setIsStock(bool $isStock): self
  346.     {
  347.         $this->isStock = $isStock;
  349.         return $this;
  350.     }
  352.     public function getIsDeclination(): ?bool
  353.     {
  354.         return $this->isDeclination;
  355.     }
  357.     public function setIsDeclination(bool $isDeclination): self
  358.     {
  359.         $this->isDeclination = $isDeclination;
  361.         return $this;
  362.     }
  364.     public function getCreatedAt(): ?\DateTimeInterface
  365.     {
  366.         return $this->createdAt;
  367.     }
  369.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  370.     {
  371.         $this->createdAt = $createdAt;
  373.         return $this;
  374.     }
  376.     /**
  377.      * @return Collection|Declination[]
  378.      */
  379.     public function getDeclinations(): Collection
  380.     {
  381.         return $this->declinations;
  382.     }
  384.     public function addDeclination(Declination $declination): self
  385.     {
  386.         if( !$this->declinations->contains($declination)) {
  387.             $this->declinations[] = $declination;
  388.             $declination->addProduit($this);
  389.         }
  391.         return $this;
  392.     }
  394.     public function removeDeclination(Declination $declination): self
  395.     {
  396.         if( $this->declinations->removeElement($declination)) {
  397.             $declination->removeProduit($this);
  398.         }
  400.         return $this;
  401.     }
  403.     /**
  404.      * @return Collection|ProduitDeclinationValue[]
  405.      */
  406.     public function getProduitDeclinationValues(): Collection
  407.     {
  408.         return $this->produitDeclinationValues;
  409.     }
  411.     public function addProduitDeclinationValue(ProduitDeclinationValue $produitDeclinationValue): self
  412.     {
  413.         if( !$this->produitDeclinationValues->contains($produitDeclinationValue)) {
  414.             $this->produitDeclinationValues[] = $produitDeclinationValue;
  415.             $produitDeclinationValue->setProduit($this);
  416.         }
  418.         return $this;
  419.     }
  421.     public function removeProduitDeclinationValue(ProduitDeclinationValue $produitDeclinationValue): self
  422.     {
  423.         if( $this->produitDeclinationValues->removeElement($produitDeclinationValue)) {
  424.             // set the owning side to null (unless already changed)
  425.             if( $produitDeclinationValue->getProduit() === $this) {
  426.                 $produitDeclinationValue->setProduit(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * @return Collection|File[]
  435.      */
  436.     public function getPicture(): Collection
  437.     {
  438.         return $this->picture;
  439.     }
  441.     public function addPicture(File $picture): self
  442.     {
  443.         if( !$this->picture->contains($picture))
  444.             $this->picture[] = $picture;
  446.         return $this;
  447.     }
  449.     public function removePicture(File $picture): self
  450.     {
  451.         $this->picture->removeElement($picture);
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection|DocumentProduit[]
  458.      */
  459.     public function getDocumentProduits(): Collection
  460.     {
  461.         return $this->documentProduits;
  462.     }
  464.     public function addDocumentProduit(DocumentProduit $documentProduit): self
  465.     {
  466.         if( !$this->documentProduits->contains($documentProduit)) {
  467.             $this->documentProduits[] = $documentProduit;
  468.             $documentProduit->setProduit($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeDocumentProduit(DocumentProduit $documentProduit): self
  475.     {
  476.         if( $this->documentProduits->removeElement($documentProduit))
  477.             // set the owning side to null (unless already changed)
  478.             if( $documentProduit->getProduit() === $this)
  479.                 $documentProduit->setProduit(null);
  481.         return $this;
  482.     }
  484.     /**
  485.      * @return Collection|Stock[]
  486.      */
  487.     public function getStocks(): Collection
  488.     {
  489.         return $this->stocks;
  490.     }
  492.     public function addStock(Stock $stock): self
  493.     {
  494.         if( !$this->stocks->contains($stock)) {
  495.             $this->stocks[] = $stock;
  496.             $stock->setProduit($this);
  497.         }
  499.         return $this;
  500.     }
  502.     public function removeStock(Stock $stock): self
  503.     {
  504.         if( $this->stocks->removeElement($stock))
  505.             // set the owning side to null (unless already changed)
  506.             if( $stock->getProduit() === $this)
  507.                 $stock->setProduit(null);
  509.         return $this;
  510.     }
  512.     public function getUuid(): ?int
  513.     {
  514.         return $this->uuid;
  515.     }
  517.     public function setUuid(?int $uuid): self
  518.     {
  519.         $this->uuid = $uuid;
  521.         return $this;
  522.     }
  524.     public function getPromotion(): ?Promotion
  525.     {
  526.         return $this->promotion;
  527.     }
  529.     public function setPromotion(?Promotion $promotion): self
  530.     {
  531.         $this->promotion = $promotion;
  532.         return $this;
  533.     }
  535.     /**
  536.      * @return Collection|Activity[]
  537.      */
  538.     public function getActivities(): Collection
  539.     {
  540.         return $this->activities;
  541.     }
  543.     public function addActivity(Activity $activity): self
  544.     {
  545.         if( !$this->activities->contains($activity)) {
  546.             $this->activities[] = $activity;
  547.             $activity->setProduit($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeActivity(Activity $activity): self
  554.     {
  555.         if( $this->activities->removeElement($activity))
  556.             // set the owning side to null (unless already changed)
  557.             if( $activity->getProduit() === $this)
  558.                 $activity->setProduit(null);
  560.         return $this;
  561.     }
  563.     public function getInformation(): ?string
  564.     {
  565.         return $this->information;
  566.     }
  568.     public function setInformation(?string $information): self
  569.     {
  570.         $this->information = $information;
  572.         return $this;
  573.     }
  575.     public function getIsArchived(): ?bool
  576.     {
  577.         return $this->isArchived;
  578.     }
  580.     public function setIsArchived(?bool $isArchived): self
  581.     {
  582.         $this->isArchived = $isArchived;
  584.         return $this;
  585.     }
  587.     /**
  588.      * @return Collection|Comment[]
  589.      */
  590.     public function getComments(): Collection
  591.     {
  592.         return $this->comments;
  593.     }
  595.     public function addComment(Comment $comment): self
  596.     {
  597.         if( !$this->comments->contains($comment)) {
  598.             $this->comments[] = $comment;
  599.             $comment->setProduit($this);
  600.         }
  601.         return $this;
  602.     }
  604.     public function removeComment(Comment $comment): self
  605.     {
  606.         if( $this->comments->removeElement($comment))
  607.             // set the owning side to null (unless already changed)
  608.             if( $comment->getProduit() === $this)
  609.                 $comment->setProduit(null);
  610.         return $this;
  611.     }
  613.     public function getIsNew(): ?bool
  614.     {
  615.         return $this->isNew;
  616.     }
  618.     public function setIsNew(bool $isNew): self
  619.     {
  620.         $this->isNew = $isNew;
  622.         return $this;
  623.     }
  625.     public function getStock(): ?int
  626.     {
  627.         foreach ($this->getStocks() as $stock) {
  628.             $this->stock += $stock->getQtAvailable() - $stock->getQtReserved();
  629.         }
  631.         return $this->stock;
  632.     }
  634.     public function setStock($stock): self
  635.     {
  636.         $this->stock = $stock;
  638.         return $this;
  639.     }
  641.     public function isNew()
  642.     {
  643.         // On va chercher les produit nouveau dont la date de création ne dépasse pas 90 jours
  644.         $date = new \DateTime('now');
  645.         $date->modify('-90 day');
  647.         if( $this->getCreatedAt() >= $date) {
  648.             $this->setIsNew(true);
  649.         }
  650.         return $this->isNew;
  651.     }
  653.     public function getBestSelection(): ?bool
  654.     {
  655.         return $this->bestSelection;
  656.     }
  658.     public function setBestSelection(bool $bestSelection): self
  659.     {
  660.         $this->bestSelection = $bestSelection;
  662.         return $this;
  663.     }
  665.     public function jsonSerialize()
  666.     {
  667.         $tabPictures = [];
  669.         foreach ($this->getPicture() as $picture) {
  670.             array_push($tabPictures, $picture->getImageName());
  671.         }
  673.         return array(
  674.             'id' => $this->getId(),
  675.             'name' => $this->getName(),
  676.             'description' => $this->getDescription(),
  677.             'specification' => $this->getInformation(),
  678.             'picture' => $tabPictures,
  679.             'image' => $this->getImage(),
  680.             'priceHT' => $this->getPriceHt(),
  681.             'priceTTC' => $this->getPriceTtc(),
  682.             'category' => $this->getCategories() ? $this->getCategories()->getId() : 0,
  683.             //'produitDeclinationValues' => $this->getProduitDeclinationValues()->toArray(),
  684.             'promo' => $this->getPromotion(),
  685.             'isNew' => $this->isNew(),
  686.             'stock' => $this->getStock(),
  687.             //'tags' => $this->getTags()->toArray(),
  688.         );
  689.     }
  691.     public function getPrincipalCategory(): ?Category
  692.     {
  693.         return $this->principalCategory;
  694.     }
  696.     public function setPrincipalCategory(?Category $principalCategory): self
  697.     {
  698.         $this->principalCategory = $principalCategory;
  700.         return $this;
  701.     }
  703.     public function getDeletedAt(): ?\DateTimeInterface
  704.     {
  705.         return $this->deletedAt;
  706.     }
  708.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  709.     {
  710.         $this->deletedAt = $deletedAt;
  712.         return $this;
  713.     }
  714.     public function getReasonOfDelete(): ?string
  715.     {
  716.         return $this->reasonOfDelete;
  717.     }
  719.     public function setReasonOfDelete(?string $reasonOfDelete): self
  720.     {
  721.         $this->reasonOfDelete = $reasonOfDelete;
  723.         return $this;
  724.     }
  726.     /**
  727.      * @return Collection|User[]
  728.      */
  729.     public function getUsers(): Collection
  730.     {
  731.         return $this->users;
  732.     }
  734.     public function addUser(User $user): self
  735.     {
  736.         if( !$this->users->contains($user)) {
  737.             $this->users[] = $user;
  738.         }
  740.         return $this;
  741.     }
  743.     public function removeUser(User $user): self
  744.     {
  745.         if( $this->users->contains($user)) {
  746.             $this->users->removeElement($user);
  747.         }
  749.         return $this;
  750.     }
  752.     public function getShowInWebsite(): ?bool
  753.     {
  754.         return $this->showInWebSite;
  755.     }
  757.     public function setShowInWebSite(?bool $showInWebSite): self
  758.     {
  759.         $this->showInWebSite = $showInWebSite;
  760.         return $this;
  761.     }
  763. }