src/Entity/Produit.php line 13

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\ProduitRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\DBAL\Types\Types;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Component\Validator\Constraints as Assert;
  9. #[ORM\Entity(repositoryClassProduitRepository::class)]
  10. class Produit
  11. {
  12.     #[ORM\Id]
  13.     #[ORM\GeneratedValue]
  14.     #[ORM\Column]
  15.     private ?int $id null;
  16.     #[ORM\Column(length255)]
  17.     #[Assert\NotBlank(message'Le nom du produit est obligatoire')]
  18.     #[Assert\Length(min2max255minMessage'Le nom doit faire au moins {{ limit }} caractères'maxMessage'Le nom ne peut pas dépasser {{ limit }} caractères')]
  19.     private ?string $Nom null;
  20.     #[ORM\Column(length255nullabletrue)]
  21.     #[Assert\Length(max255maxMessage'La description ne peut pas dépasser {{ limit }} caractères')]
  22.     private ?string $Description null;
  23.     #[ORM\Column(typeTypes::DECIMALprecision10scale2)]
  24.     #[Assert\PositiveOrZero(message'Le prix unitaire doit être positif ou zéro')]
  25.     private ?string $prixUnitaire '0';
  26.     #[ORM\Column(typeTypes::DECIMALprecision10scale2)]
  27.     #[Assert\PositiveOrZero(message'La quantité totale doit être positive ou zéro')]
  28.     private ?string $quantiteTotale '0';
  29.     #[ORM\Column(typeTypes::DECIMALprecision10scale2)]
  30.     #[Assert\PositiveOrZero(message'La quantité d\'alerte doit être positive ou zéro')]
  31.     private ?string $quantiteAlerte '0';
  32.     #[ORM\ManyToOne(inversedBy'produits')]
  33.     #[ORM\JoinColumn(nullablefalse)]
  34.     #[Assert\NotNull(message'La catégorie est obligatoire')]
  35.     private ?Categorie $categorie null;
  36.     #[ORM\OneToMany(mappedBy'produit'targetEntityEntreeStock::class)]
  37.     private Collection $entreeStocks;
  38.     #[ORM\OneToMany(mappedBy'produit'targetEntitySortieStock::class)]
  39.     private Collection $sortieStocks;
  40.     #[ORM\ManyToOne(inversedBy'produits')]
  41.     #[ORM\JoinColumn(nullabletrueonDelete'SET NULL')]
  42.     private ?User $utilisateur null;
  43.     #[ORM\Column(length255nullabletrue)]
  44.     #[Assert\Length(max255maxMessage'Le code-barres ne peut pas dépasser {{ limit }} caractères')]
  45.     private ?string $codeBar null;
  46.     #[ORM\Column(typeTypes::DECIMALprecision10scale2nullabletrue)]
  47.     #[Assert\PositiveOrZero(message'La quantité de production doit être positive ou zéro')]
  48.     private ?string $quantitePr null;
  49.     #[ORM\Column(typeTypes::DECIMALprecision10scale2nullabletrue)]
  50.     #[Assert\PositiveOrZero(message'Le coût doit être positif ou zéro')]
  51.     private ?string $cout null;
  52.     #[ORM\Column(length255nullabletrue)]
  53.     #[Assert\Length(max255maxMessage'Le numéro de lot ne peut pas dépasser {{ limit }} caractères')]
  54.     private ?string $numeroLot null;
  55.     #[ORM\Column(typeTypes::DATETIME_MUTABLEnullabletrue)]
  56.     private ?\DateTimeInterface $datePeremption null;
  57.     #[ORM\Column(length255nullabletrue)]
  58.     #[Assert\Length(max255maxMessage'L\'unité de mesure ne peut pas dépasser {{ limit }} caractères')]
  59.     private ?string $uniteMesure null;
  60.     #[ORM\OneToMany(mappedBy'produits'targetEntityMenuProduit::class)]
  61.     private Collection $menuProduits;
  62.     public function __construct()
  63.     {
  64.         $this->prixUnitaire '0';
  65.         $this->quantiteAlerte '0';
  66.         $this->entreeStocks = new ArrayCollection();
  67.         $this->sortieStocks = new ArrayCollection();
  68.         $this->menuProduits = new ArrayCollection();
  69.     }
  70.     public function getId(): ?int
  71.     {
  72.         return $this->id;
  73.     }
  74.     public function getNom(): ?string
  75.     {
  76.         return $this->Nom;
  77.     }
  78.     public function setNom(string $Nom): static
  79.     {
  80.         $this->Nom $Nom;
  81.         return $this;
  82.     }
  83.     public function getDescription(): ?string
  84.     {
  85.         return $this->Description;
  86.     }
  87.     public function setDescription(string $Description): static
  88.     {
  89.         $this->Description $Description;
  90.         return $this;
  91.     }
  92.     public function getPrixUnitaire(): ?string
  93.     {
  94.         return $this->prixUnitaire;
  95.     }
  96.     public function setPrixUnitaire(string $prixUnitaire): static
  97.     {
  98.         $this->prixUnitaire $prixUnitaire;
  99.         return $this;
  100.     }
  101.     public function getQuantiteTotale(): ?string
  102.     {
  103.         return $this->quantiteTotale;
  104.     }
  105.     public function setQuantiteTotale(string $quantiteTotale): static
  106.     {
  107.         $this->quantiteTotale $quantiteTotale;
  108.         return $this;
  109.     }
  110.     public function getQuantiteAlerte(): ?string
  111.     {
  112.         return $this->quantiteAlerte;
  113.     }
  114.     public function setQuantiteAlerte(string $quantiteAlerte): static
  115.     {
  116.         $this->quantiteAlerte $quantiteAlerte;
  117.         return $this;
  118.     }
  119.     public function getCategorie(): ?Categorie
  120.     {
  121.         return $this->categorie;
  122.     }
  123.     public function setCategorie(?Categorie $categorie): static
  124.     {
  125.         $this->categorie $categorie;
  126.         return $this;
  127.     }
  128.     public function getEntreeStocks(): Collection
  129.     {
  130.         return $this->entreeStocks;
  131.     }
  132.     public function addEntreeStock(EntreeStock $entreeStock): static
  133.     {
  134.         if (!$this->entreeStocks->contains($entreeStock)) {
  135.             $this->entreeStocks->add($entreeStock);
  136.             $entreeStock->setProduit($this);
  137.         }
  138.         return $this;
  139.     }
  140.     public function removeEntreeStock(EntreeStock $entreeStock): static
  141.     {
  142.         if ($this->entreeStocks->removeElement($entreeStock)) {
  143.             if ($entreeStock->getProduit() === $this) {
  144.                 $entreeStock->setProduit(null);
  145.             }
  146.         }
  147.         return $this;
  148.     }
  149.     public function getSortieStocks(): Collection
  150.     {
  151.         return $this->sortieStocks;
  152.     }
  153.     public function addSortieStock(SortieStock $sortieStock): static
  154.     {
  155.         if (!$this->sortieStocks->contains($sortieStock)) {
  156.             $this->sortieStocks->add($sortieStock);
  157.             $sortieStock->setProduit($this);
  158.         }
  159.         return $this;
  160.     }
  161.     public function removeSortieStock(SortieStock $sortieStock): static
  162.     {
  163.         if ($this->sortieStocks->removeElement($sortieStock)) {
  164.             if ($sortieStock->getProduit() === $this) {
  165.                 $sortieStock->setProduit(null);
  166.             }
  167.         }
  168.         return $this;
  169.     }
  170.     public function getUtilisateur(): ?User
  171.     {
  172.         return $this->utilisateur;
  173.     }
  174.     public function setUtilisateur(?User $utilisateur): static
  175.     {
  176.         $this->utilisateur $utilisateur;
  177.         return $this;
  178.     }
  179.     public function getCodeBar(): ?string
  180.     {
  181.         return $this->codeBar;
  182.     }
  183.     public function setCodeBar(?string $codeBar): static
  184.     {
  185.         $this->codeBar $codeBar;
  186.         return $this;
  187.     }
  188.     public function getQuantitePr(): ?string
  189.     {
  190.         return $this->quantitePr;
  191.     }
  192.     public function setQuantitePr(?string $quantitePr): static
  193.     {
  194.         $this->quantitePr $quantitePr;
  195.         return $this;
  196.     }
  197.     public function getCout(): ?string
  198.     {
  199.         return $this->cout;
  200.     }
  201.     public function setCout(?string $cout): static
  202.     {
  203.         $this->cout $cout;
  204.         return $this;
  205.     }
  206.     public function getNumeroLot(): ?string
  207.     {
  208.         return $this->numeroLot;
  209.     }
  210.     public function setNumeroLot(?string $numeroLot): static
  211.     {
  212.         $this->numeroLot $numeroLot;
  213.         return $this;
  214.     }
  215.     public function getDatePeremption(): ?\DateTimeInterface
  216.     {
  217.         return $this->datePeremption;
  218.     }
  219.     public function setDatePeremption(?\DateTimeInterface $datePeremption): static
  220.     {
  221.         $this->datePeremption $datePeremption;
  222.         return $this;
  223.     }
  224.     public function getUniteMesure(): ?string
  225.     {
  226.         return $this->uniteMesure;
  227.     }
  228.     public function setUniteMesure(?string $uniteMesure): static
  229.     {
  230.         $this->uniteMesure $uniteMesure;
  231.         return $this;
  232.     }
  233.     public function getMenuProduits(): Collection
  234.     {
  235.         return $this->menuProduits;
  236.     }
  237.     public function addMenuProduit(MenuProduit $menuProduit): static
  238.     {
  239.         if (!$this->menuProduits->contains($menuProduit)) {
  240.             $this->menuProduits->add($menuProduit);
  241.             $menuProduit->setProduits($this);
  242.         }
  243.         return $this;
  244.     }
  245.     public function removeMenuProduit(MenuProduit $menuProduit): static
  246.     {
  247.         if ($this->menuProduits->removeElement($menuProduit)) {
  248.             if ($menuProduit->getProduits() === $this) {
  249.                 $menuProduit->setProduits(null);
  250.             }
  251.         }
  252.         return $this;
  253.     }
  254. }