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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\HttpFoundation\File\File;
  11. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  13. #[ORM\Entity(repositoryClass: ProduitRepository::class)]
  14. #[Vich\Uploadable]
  15. class Produit
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $Nom = null;
  25.     #[ORM\Column(length: 255,nullable: true)]
  26.     private ?string $Description = null;
  28.     #[ORM\Column(nullable: true)]
  29.     private ?int $prixUnitaire = null;
  31.     #[ORM\ManyToOne(inversedBy: 'produits')]
  32.     #[ORM\JoinColumn(nullable: false)]
  33.     private ?Categorie $categorie = null;
  35.   
  37.     #[ORM\OneToMany(mappedBy: 'produit', targetEntity: EntreeStock::class)]
  38.     private Collection $entreeStocks;
  40.     #[ORM\OneToMany(mappedBy: 'produit', targetEntity: SortieStock::class)]
  41.     private Collection $sortieStocks;
  43.     #[ORM\ManyToOne(inversedBy: 'produits')]
  44.     private ?User $utilisateur = null;
  46.     
  48.     #[ORM\Column(nullable: true)]
  49.     private ?int $quantitePr = null;
  51.     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
  52.     private ?string $cout = null;
  54.     
  55.     
  56.     #[Vich\UploadableField(mapping: 'produit', fileNameProperty: 'imageName', )]
  57.     private ?File $imageFile = null;
  59.     #[ORM\Column(nullable: true)]
  60.     private ?string $imageName = null;
  62.     
  63.     #[ORM\Column(nullable: true)]
  64.     private ?\DateTimeImmutable $updatedAt = null;
  66.     #[ORM\Column(length: 255, nullable: true)]
  67.     private ?string $uniteMesure = null;
  69.     #[ORM\OneToMany(mappedBy: 'produit', targetEntity: DetailsVente::class, cascade: ['remove'], orphanRemoval: true)]
  70.     private Collection $detailsVentes;
  72.     #[ORM\OneToMany(mappedBy: 'produit', targetEntity: LivraisonProd::class, cascade: ['remove'], orphanRemoval: true)]
  73.     private Collection $livraisonProds;
  75.     #[ORM\OneToMany(mappedBy: 'produit', targetEntity: ProduitStock::class)]
  76.     private Collection $produitStocks;
  78.     #[ORM\Column(nullable: true)]
  79.     private ?float $prixVenteUnitaire = null;
  81.     public function __construct()
  82.     {
  83.         $this->entreeStocks = new ArrayCollection();
  84.         $this->sortieStocks = new ArrayCollection();
  85.         $this->detailsVentes = new ArrayCollection();
  86.         $this->updatedAt = new \DateTimeImmutable('now');
  87.         $this->livraisonProds = new ArrayCollection();
  88.         $this->produitStocks = new ArrayCollection();
  89.         $this->prixVenteUnitaire = 0;
  90.     }
  92.     public function getId(): ?int
  93.     {
  94.         return $this->id;
  95.     }
  97.     public function getNom(): ?string
  98.     {
  99.         return $this->Nom;
  100.     }
  102.     public function setNom(string $Nom): static
  103.     {
  104.         $this->Nom = $Nom;
  106.         return $this;
  107.     }
  109.     public function getDescription(): ?string
  110.     {
  111.         return $this->Description;
  112.     }
  114.     public function setDescription(string $Description): static
  115.     {
  116.         $this->Description = $Description;
  118.         return $this;
  119.     }
  121.     public function getPrixUnitaire(): ?int
  122.     {
  123.         return $this->prixUnitaire;
  124.     }
  126.     public function setPrixUnitaire(int $prixUnitaire): static
  127.     {
  128.         $this->prixUnitaire = $prixUnitaire;
  130.         return $this;
  131.     }
  133.    
  136.     
  138.     public function getCategorie(): ?Categorie
  139.     {
  140.         return $this->categorie;
  141.     }
  143.     public function setCategorie(?Categorie $categorie): static
  144.     {
  145.         $this->categorie = $categorie;
  147.         return $this;
  148.     }
  150.  
  152.    
  154.     /**
  155.      * @return Collection<int, EntreeStock>
  156.      */
  157.     public function getEntreeStocks(): Collection
  158.     {
  159.         return $this->entreeStocks;
  160.     }
  162.     public function addEntreeStock(EntreeStock $entreeStock): static
  163.     {
  164.         if (!$this->entreeStocks->contains($entreeStock)) {
  165.             $this->entreeStocks->add($entreeStock);
  166.             $entreeStock->setProduit($this);
  167.         }
  169.         return $this;
  170.     }
  172.     public function removeEntreeStock(EntreeStock $entreeStock): static
  173.     {
  174.         if ($this->entreeStocks->removeElement($entreeStock)) {
  175.             // set the owning side to null (unless already changed)
  176.             if ($entreeStock->getProduit() === $this) {
  177.                 $entreeStock->setProduit(null);
  178.             }
  179.         }
  181.         return $this;
  182.     }
  184.     /**
  185.      * @return Collection<int, SortieStock>
  186.      */
  187.     public function getSortieStocks(): Collection
  188.     {
  189.         return $this->sortieStocks;
  190.     }
  192.     public function addSortieStock(SortieStock $sortieStock): static
  193.     {
  194.         if (!$this->sortieStocks->contains($sortieStock)) {
  195.             $this->sortieStocks->add($sortieStock);
  196.             $sortieStock->setProduit($this);
  197.         }
  199.         return $this;
  200.     }
  202.     public function removeSortieStock(SortieStock $sortieStock): static
  203.     {
  204.         if ($this->sortieStocks->removeElement($sortieStock)) {
  205.             // set the owning side to null (unless already changed)
  206.             if ($sortieStock->getProduit() === $this) {
  207.                 $sortieStock->setProduit(null);
  208.             }
  209.         }
  211.         return $this;
  212.     }
  213.     public function setImageFile(?File $imageFile = null): void
  214.     {
  215.         $this->imageFile = $imageFile;
  217.         if (null !== $imageFile) {
  218.             
  219.             $this->updatedAt = new \DateTimeImmutable('now');
  220.         }
  221.     }
  223.     public function getImageFile(): ?File
  224.     {
  225.         return $this->imageFile;
  226.     }
  228.     public function setImageName(?string $imageName): void
  229.     {
  230.         $this->imageName = $imageName;
  231.     }
  233.     public function getImageName(): ?string
  234.     {
  235.         return $this->imageName;
  236.     }
  238.     public function getUtilisateur(): ?User
  239.     {
  240.         return $this->utilisateur;
  241.     }
  243.     public function setUtilisateur(?User $utilisateur): static
  244.     {
  245.         $this->utilisateur = $utilisateur;
  247.         return $this;
  248.     }
  250.    
  252.     
  254.     public function getQuantitePr(): ?int
  255.     {
  256.         return $this->quantitePr;
  257.     }
  259.     public function setQuantitePr(?int $quantitePr): static
  260.     {
  261.         $this->quantitePr = $quantitePr;
  263.         return $this;
  264.     }
  266.     public function getCout(): ?string
  267.     {
  268.         return $this->cout;
  269.     }
  271.     public function setCout(?string $cout): static
  272.     {
  273.         $this->cout = $cout;
  275.         return $this;
  276.     }
  278.     
  280.     
  282.   
  284.     public function getUniteMesure(): ?string
  285.     {
  286.         return $this->uniteMesure;
  287.     }
  289.     public function setUniteMesure(?string $uniteMesure): static
  290.     {
  291.         $this->uniteMesure = $uniteMesure;
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return Collection<int, DetailsVente>
  298.      */
  299.     public function getDetailsVentes(): Collection
  300.     {
  301.         return $this->detailsVentes;
  302.     }
  304.     public function addDetailsVente(DetailsVente $detailsVente): static
  305.     {
  306.         if (!$this->detailsVentes->contains($detailsVente)) {
  307.             $this->detailsVentes->add($detailsVente);
  308.             $detailsVente->setProduit($this);
  309.         }
  311.         return $this;
  312.     }
  314.     public function removeDetailsVente(DetailsVente $detailsVente): static
  315.     {
  316.         if ($this->detailsVentes->removeElement($detailsVente)) {
  317.             // set the owning side to null (unless already changed)
  318.             if ($detailsVente->getProduit() === $this) {
  319.                 $detailsVente->setProduit(null);
  320.             }
  321.         }
  323.         return $this;
  324.     }
  326.     /**
  327.      * @return Collection<int, LivraisonProd>
  328.      */
  329.     public function getLivraisonProds(): Collection
  330.     {
  331.         return $this->livraisonProds;
  332.     }
  334.     public function addLivraisonProd(LivraisonProd $livraisonProd): static
  335.     {
  336.         if (!$this->livraisonProds->contains($livraisonProd)) {
  337.             $this->livraisonProds->add($livraisonProd);
  338.             $livraisonProd->setProduit($this);
  339.         }
  341.         return $this;
  342.     }
  344.     public function removeLivraisonProd(LivraisonProd $livraisonProd): static
  345.     {
  346.         if ($this->livraisonProds->removeElement($livraisonProd)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($livraisonProd->getProduit() === $this) {
  349.                 $livraisonProd->setProduit(null);
  350.             }
  351.         }
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection<int, ProduitStock>
  358.      */
  359.     public function getProduitStocks(): Collection
  360.     {
  361.         return $this->produitStocks;
  362.     }
  364.     public function addProduitStock(ProduitStock $produitStock): static
  365.     {
  366.         if (!$this->produitStocks->contains($produitStock)) {
  367.             $this->produitStocks->add($produitStock);
  368.             $produitStock->setProduit($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeProduitStock(ProduitStock $produitStock): static
  375.     {
  376.         if ($this->produitStocks->removeElement($produitStock)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($produitStock->getProduit() === $this) {
  379.                 $produitStock->setProduit(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     public function getPrixVenteUnitaire(): ?float
  387.     {
  388.         return $this->prixVenteUnitaire;
  389.     }
  391.     public function setPrixVenteUnitaire(?float $prixVenteUnitaire): static
  392.     {
  393.         $this->prixVenteUnitaire = $prixVenteUnitaire;
  395.         return $this;
  396.     }
  397. }