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;
  43.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: Recette::class)]
  44.     private Collection $recettes;
  46.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: User::class)]
  47.     private Collection $users;
  48.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: FactureService::class)]
  49.     private Collection $factureServices;
  52.     public function __construct()
  53.     {
  54.         $this->boutiques = new ArrayCollection();
  55.         $this->produitStock = new ArrayCollection();
  56.         $this->sortieStocks = new ArrayCollection();
  57.         $this->ventes = new ArrayCollection();
  58.         $this->entreeStocks = new ArrayCollection();
  59.         $this->recettes = new ArrayCollection();
  60.         $this->users = new ArrayCollection();
  61.         $this->factureServices = new ArrayCollection();
  62.     }
  64.     public function getId(): ?int
  65.     {
  66.         return $this->id;
  67.     }
  69.     public function getNom(): ?string
  70.     {
  71.         return $this->nom;
  72.     }
  74.     public function setNom(string $nom): static
  75.     {
  76.         $this->nom = $nom;
  78.         return $this;
  79.     }
  81.     public function getBoutiqueMere(): ?self
  82.     {
  83.         return $this->boutiqueMere;
  84.     }
  86.     public function setBoutiqueMere(?self $boutiqueMere): static
  87.     {
  88.         $this->boutiqueMere = $boutiqueMere;
  90.         return $this;
  91.     }
  93.     /**
  94.      * @return Collection<int, self>
  95.      */
  96.     public function getBoutiques(): Collection
  97.     {
  98.         return $this->boutiques;
  99.     }
  101.     public function addBoutique(self $boutique): static
  102.     {
  103.         if (!$this->boutiques->contains($boutique)) {
  104.             $this->boutiques->add($boutique);
  105.             $boutique->setBoutiqueMere($this);
  106.         }
  108.         return $this;
  109.     }
  111.     public function removeBoutique(self $boutique): static
  112.     {
  113.         if ($this->boutiques->removeElement($boutique)) {
  114.             // set the owning side to null (unless already changed)
  115.             if ($boutique->getBoutiqueMere() === $this) {
  116.                 $boutique->setBoutiqueMere(null);
  117.             }
  118.         }
  120.         return $this;
  121.     }
  123.     /**
  124.      * @return Collection<int, ProduitStock>
  125.      */
  126.     public function getProduitStock(): Collection
  127.     {
  128.         return $this->produitStock;
  129.     }
  131.     public function addProduitStock(ProduitStock $produitStock): static
  132.     {
  133.         if (!$this->produitStock->contains($produitStock)) {
  134.             $this->produitStock->add($produitStock);
  135.             $produitStock->setBoutique($this);
  136.         }
  138.         return $this;
  139.     }
  141.     public function removeProduitStock(ProduitStock $produitStock): static
  142.     {
  143.         if ($this->produitStock->removeElement($produitStock)) {
  144.             // set the owning side to null (unless already changed)
  145.             if ($produitStock->getBoutique() === $this) {
  146.                 $produitStock->setBoutique(null);
  147.             }
  148.         }
  150.         return $this;
  151.     }
  153.     /**
  154.      * @return Collection<int, SortieStock>
  155.      */
  156.     public function getSortieStocks(): Collection
  157.     {
  158.         return $this->sortieStocks;
  159.     }
  161.     public function addSortieStock(SortieStock $sortieStock): static
  162.     {
  163.         if (!$this->sortieStocks->contains($sortieStock)) {
  164.             $this->sortieStocks->add($sortieStock);
  165.             $sortieStock->setBoutique($this);
  166.         }
  168.         return $this;
  169.     }
  171.     public function removeSortieStock(SortieStock $sortieStock): static
  172.     {
  173.         if ($this->sortieStocks->removeElement($sortieStock)) {
  174.             // set the owning side to null (unless already changed)
  175.             if ($sortieStock->getBoutique() === $this) {
  176.                 $sortieStock->setBoutique(null);
  177.             }
  178.         }
  180.         return $this;
  181.     }
  183.     /**
  184.      * @return Collection<int, Vente>
  185.      */
  186.     public function getVentes(): Collection
  187.     {
  188.         return $this->ventes;
  189.     }
  191.     public function addVente(Vente $vente): static
  192.     {
  193.         if (!$this->ventes->contains($vente)) {
  194.             $this->ventes->add($vente);
  195.             $vente->setBoutique($this);
  196.         }
  198.         return $this;
  199.     }
  201.     public function removeVente(Vente $vente): static
  202.     {
  203.         if ($this->ventes->removeElement($vente)) {
  204.             // set the owning side to null (unless already changed)
  205.             if ($vente->getBoutique() === $this) {
  206.                 $vente->setBoutique(null);
  207.             }
  208.         }
  210.         return $this;
  211.     }
  213.     /**
  214.      * @return Collection<int, EntreeStock>
  215.      */
  216.     public function getEntreeStocks(): Collection
  217.     {
  218.         return $this->entreeStocks;
  219.     }
  221.     public function addEntreeStock(EntreeStock $entreeStock): static
  222.     {
  223.         if (!$this->entreeStocks->contains($entreeStock)) {
  224.             $this->entreeStocks->add($entreeStock);
  225.             $entreeStock->setBoutique($this);
  226.         }
  228.         return $this;
  229.     }
  231.     public function removeEntreeStock(EntreeStock $entreeStock): static
  232.     {
  233.         if ($this->entreeStocks->removeElement($entreeStock)) {
  234.             // set the owning side to null (unless already changed)
  235.             if ($entreeStock->getBoutique() === $this) {
  236.                 $entreeStock->setBoutique(null);
  237.             }
  238.         }
  240.         return $this;
  241.     }
  243.     public function isIsMere(): ?bool
  244.     {
  245.         return $this->isMere;
  246.     }
  248.     public function setIsMere(?bool $isMere): static
  249.     {
  250.         $this->isMere = $isMere;
  252.         return $this;
  253.     }
  256.     /**
  257.      * @return Collection<int, Recette>
  258.      */
  259.     public function getRecettes(): Collection
  260.     {
  261.         return $this->recettes;
  262.     }
  264.     public function addRecette(Recette $recette): static
  265.     {
  266.         if (!$this->recettes->contains($recette)) {
  267.             $this->recettes->add($recette);
  268.             $recette->setBoutique($this);
  269.         }
  271.         return $this;
  272.     }
  274.     public function removeRecette(Recette $recette): static
  275.     {
  276.         if ($this->recettes->removeElement($recette)) {
  277.             // set the owning side to null (unless already changed)
  278.             if ($recette->getBoutique() === $this) {
  279.                 $recette->setBoutique(null);
  280.             }
  281.         }
  283.         return $this;
  284.     }
  286.     /**
  287.      * @return Collection<int, User>
  288.      */
  289.     public function getUsers(): Collection
  290.     {
  291.         return $this->users;
  292.     }
  294.     public function addUser(User $user): static
  295.     {
  296.         if (!$this->users->contains($user)) {
  297.             $this->users->add($user);
  298.             $user->setBoutique($this);
  299.         }
  301.         return $this;
  302.     }
  304.     public function removeUser(User $user): static
  305.     {
  306.         if ($this->users->removeElement($user)) {
  307.             // set the owning side to null (unless already changed)
  308.             if ($user->getBoutique() === $this) {
  309.                 $user->setBoutique(null);
  310.             }
  311.         }
  313.         return $this;
  314.     }
  315.      /**
  316.      * @return Collection<int, FactureService>
  317.      */
  318.     public function getFactureServices(): Collection
  319.     {
  320.         return $this->factureServices;
  321.     }
  323.     public function addFactureService(FactureService $factureService): static
  324.     {
  325.         if (!$this->factureServices->contains($factureService)) {
  326.             $this->factureServices->add($factureService);
  327.             $factureService->setBoutique($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeFactureService(FactureService $factureService): static
  334.     {
  335.         if ($this->factureServices->removeElement($factureService)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($factureService->getBoutique() === $this) {
  338.                 $factureService->setBoutique(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.   
  346. }