src/Entity/Boutique.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\BoutiqueRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: BoutiqueRepository::class)]
  11. class Boutique
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column]
  16.     private ?int $id = null;
  18.     #[ORM\Column(length: 255)]
  19.     private ?string $nom = null;
  21.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'boutiques')]
  22.     private ?self $boutiqueMere = null;
  24.     #[ORM\OneToMany(mappedBy: 'boutiqueMere', targetEntity: self::class)]
  25.     private Collection $boutiques;
  27.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: ProduitStock::class)]
  28.     private Collection $produitStock;
  30.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: SortieStock::class)]
  31.     private Collection $sortieStocks;
  33.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: Vente::class)]
  34.     private Collection $ventes;
  36.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: EntreeStock::class)]
  37.     private Collection $entreeStocks;
  39.     #[ORM\Column(nullable: true)]
  40.     private ?bool $isMere = null;
  42.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: User::class)]
  43.     private Collection $users;
  45.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: Recette::class)]
  46.     private Collection $recettes;
  48.     public function __construct()
  49.     {
  50.         $this->boutiques = new ArrayCollection();
  51.         $this->produitStock = new ArrayCollection();
  52.         $this->sortieStocks = new ArrayCollection();
  53.         $this->ventes = new ArrayCollection();
  54.         $this->entreeStocks = new ArrayCollection();
  55.         $this->users = new ArrayCollection();
  56.         $this->recettes = new ArrayCollection();
  57.     }
  59.     public function getId(): ?int
  60.     {
  61.         return $this->id;
  62.     }
  64.     public function getNom(): ?string
  65.     {
  66.         return $this->nom;
  67.     }
  69.     public function setNom(string $nom): static
  70.     {
  71.         $this->nom = $nom;
  73.         return $this;
  74.     }
  76.     public function getBoutiqueMere(): ?self
  77.     {
  78.         return $this->boutiqueMere;
  79.     }
  81.     public function setBoutiqueMere(?self $boutiqueMere): static
  82.     {
  83.         $this->boutiqueMere = $boutiqueMere;
  85.         return $this;
  86.     }
  88.     /**
  89.      * @return Collection<int, self>
  90.      */
  91.     public function getBoutiques(): Collection
  92.     {
  93.         return $this->boutiques;
  94.     }
  96.     public function addBoutique(self $boutique): static
  97.     {
  98.         if (!$this->boutiques->contains($boutique)) {
  99.             $this->boutiques->add($boutique);
  100.             $boutique->setBoutiqueMere($this);
  101.         }
  103.         return $this;
  104.     }
  106.     public function removeBoutique(self $boutique): static
  107.     {
  108.         if ($this->boutiques->removeElement($boutique)) {
  109.             // set the owning side to null (unless already changed)
  110.             if ($boutique->getBoutiqueMere() === $this) {
  111.                 $boutique->setBoutiqueMere(null);
  112.             }
  113.         }
  115.         return $this;
  116.     }
  118.     /**
  119.      * @return Collection<int, ProduitStock>
  120.      */
  121.     public function getProduitStock(): Collection
  122.     {
  123.         return $this->produitStock;
  124.     }
  126.     public function addProduitStock(ProduitStock $produitStock): static
  127.     {
  128.         if (!$this->produitStock->contains($produitStock)) {
  129.             $this->produitStock->add($produitStock);
  130.             $produitStock->setBoutique($this);
  131.         }
  133.         return $this;
  134.     }
  136.     public function removeProduitStock(ProduitStock $produitStock): static
  137.     {
  138.         if ($this->produitStock->removeElement($produitStock)) {
  139.             // set the owning side to null (unless already changed)
  140.             if ($produitStock->getBoutique() === $this) {
  141.                 $produitStock->setBoutique(null);
  142.             }
  143.         }
  145.         return $this;
  146.     }
  148.     /**
  149.      * @return Collection<int, SortieStock>
  150.      */
  151.     public function getSortieStocks(): Collection
  152.     {
  153.         return $this->sortieStocks;
  154.     }
  156.     public function addSortieStock(SortieStock $sortieStock): static
  157.     {
  158.         if (!$this->sortieStocks->contains($sortieStock)) {
  159.             $this->sortieStocks->add($sortieStock);
  160.             $sortieStock->setBoutique($this);
  161.         }
  163.         return $this;
  164.     }
  166.     public function removeSortieStock(SortieStock $sortieStock): static
  167.     {
  168.         if ($this->sortieStocks->removeElement($sortieStock)) {
  169.             // set the owning side to null (unless already changed)
  170.             if ($sortieStock->getBoutique() === $this) {
  171.                 $sortieStock->setBoutique(null);
  172.             }
  173.         }
  175.         return $this;
  176.     }
  178.     /**
  179.      * @return Collection<int, Vente>
  180.      */
  181.     public function getVentes(): Collection
  182.     {
  183.         return $this->ventes;
  184.     }
  186.     public function addVente(Vente $vente): static
  187.     {
  188.         if (!$this->ventes->contains($vente)) {
  189.             $this->ventes->add($vente);
  190.             $vente->setBoutique($this);
  191.         }
  193.         return $this;
  194.     }
  196.     public function removeVente(Vente $vente): static
  197.     {
  198.         if ($this->ventes->removeElement($vente)) {
  199.             // set the owning side to null (unless already changed)
  200.             if ($vente->getBoutique() === $this) {
  201.                 $vente->setBoutique(null);
  202.             }
  203.         }
  205.         return $this;
  206.     }
  208.     /**
  209.      * @return Collection<int, EntreeStock>
  210.      */
  211.     public function getEntreeStocks(): Collection
  212.     {
  213.         return $this->entreeStocks;
  214.     }
  216.     public function addEntreeStock(EntreeStock $entreeStock): static
  217.     {
  218.         if (!$this->entreeStocks->contains($entreeStock)) {
  219.             $this->entreeStocks->add($entreeStock);
  220.             $entreeStock->setBoutique($this);
  221.         }
  223.         return $this;
  224.     }
  226.     public function removeEntreeStock(EntreeStock $entreeStock): static
  227.     {
  228.         if ($this->entreeStocks->removeElement($entreeStock)) {
  229.             // set the owning side to null (unless already changed)
  230.             if ($entreeStock->getBoutique() === $this) {
  231.                 $entreeStock->setBoutique(null);
  232.             }
  233.         }
  235.         return $this;
  236.     }
  238.     public function isIsMere(): ?bool
  239.     {
  240.         return $this->isMere;
  241.     }
  243.     public function setIsMere(?bool $isMere): static
  244.     {
  245.         $this->isMere = $isMere;
  247.         return $this;
  248.     }
  250.     /**
  251.      * @return Collection<int, User>
  252.      */
  253.     public function getUsers(): Collection
  254.     {
  255.         return $this->users;
  256.     }
  258.     public function addUser(User $user): static
  259.     {
  260.         if (!$this->users->contains($user)) {
  261.             $this->users->add($user);
  262.             $user->setBoutique($this);
  263.         }
  265.         return $this;
  266.     }
  268.     public function removeUser(User $user): static
  269.     {
  270.         if ($this->users->removeElement($user)) {
  271.             // set the owning side to null (unless already changed)
  272.             if ($user->getBoutique() === $this) {
  273.                 $user->setBoutique(null);
  274.             }
  275.         }
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return Collection<int, Recette>
  282.      */
  283.     public function getRecettes(): Collection
  284.     {
  285.         return $this->recettes;
  286.     }
  288.     public function addRecette(Recette $recette): static
  289.     {
  290.         if (!$this->recettes->contains($recette)) {
  291.             $this->recettes->add($recette);
  292.             $recette->setBoutique($this);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeRecette(Recette $recette): static
  299.     {
  300.         if ($this->recettes->removeElement($recette)) {
  301.             // set the owning side to null (unless already changed)
  302.             if ($recette->getBoutique() === $this) {
  303.                 $recette->setBoutique(null);
  304.             }
  305.         }
  307.         return $this;
  308.     }
  309. }