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.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: Exercice::class)]
  49.     private Collection $exercices;
  51.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: EcritureComptable::class)]
  52.     private Collection $ecrituresComptables;
  54.     #[ORM\OneToMany(mappedBy: 'boutique', targetEntity: Caisse::class, orphanRemoval: true)]
  55.     private Collection $caisses;
  57.     public function __construct()
  58.     {
  59.         $this->boutiques = new ArrayCollection();
  60.         $this->produitStock = new ArrayCollection();
  61.         $this->sortieStocks = new ArrayCollection();
  62.         $this->ventes = new ArrayCollection();
  63.         $this->entreeStocks = new ArrayCollection();
  64.         $this->users = new ArrayCollection();
  65.         $this->recettes = new ArrayCollection();
  66.         $this->exercices = new ArrayCollection();
  67.         $this->ecrituresComptables = new ArrayCollection();
  68.         $this->caisses = new ArrayCollection();
  69.     }
  71.     public function getId(): ?int
  72.     {
  73.         return $this->id;
  74.     }
  76.     public function getNom(): ?string
  77.     {
  78.         return $this->nom;
  79.     }
  81.     public function setNom(string $nom): static
  82.     {
  83.         $this->nom = $nom;
  85.         return $this;
  86.     }
  88.     public function getBoutiqueMere(): ?self
  89.     {
  90.         return $this->boutiqueMere;
  91.     }
  93.     public function setBoutiqueMere(?self $boutiqueMere): static
  94.     {
  95.         $this->boutiqueMere = $boutiqueMere;
  97.         return $this;
  98.     }
  100.     /**
  101.      * @return Collection<int, self>
  102.      */
  103.     public function getBoutiques(): Collection
  104.     {
  105.         return $this->boutiques;
  106.     }
  108.     public function addBoutique(self $boutique): static
  109.     {
  110.         if (!$this->boutiques->contains($boutique)) {
  111.             $this->boutiques->add($boutique);
  112.             $boutique->setBoutiqueMere($this);
  113.         }
  115.         return $this;
  116.     }
  118.     public function removeBoutique(self $boutique): static
  119.     {
  120.         if ($this->boutiques->removeElement($boutique)) {
  121.             // set the owning side to null (unless already changed)
  122.             if ($boutique->getBoutiqueMere() === $this) {
  123.                 $boutique->setBoutiqueMere(null);
  124.             }
  125.         }
  127.         return $this;
  128.     }
  130.     /**
  131.      * @return Collection<int, ProduitStock>
  132.      */
  133.     public function getProduitStock(): Collection
  134.     {
  135.         return $this->produitStock;
  136.     }
  138.     public function addProduitStock(ProduitStock $produitStock): static
  139.     {
  140.         if (!$this->produitStock->contains($produitStock)) {
  141.             $this->produitStock->add($produitStock);
  142.             $produitStock->setBoutique($this);
  143.         }
  145.         return $this;
  146.     }
  148.     public function removeProduitStock(ProduitStock $produitStock): static
  149.     {
  150.         if ($this->produitStock->removeElement($produitStock)) {
  151.             // set the owning side to null (unless already changed)
  152.             if ($produitStock->getBoutique() === $this) {
  153.                 $produitStock->setBoutique(null);
  154.             }
  155.         }
  157.         return $this;
  158.     }
  160.     /**
  161.      * @return Collection<int, SortieStock>
  162.      */
  163.     public function getSortieStocks(): Collection
  164.     {
  165.         return $this->sortieStocks;
  166.     }
  168.     public function addSortieStock(SortieStock $sortieStock): static
  169.     {
  170.         if (!$this->sortieStocks->contains($sortieStock)) {
  171.             $this->sortieStocks->add($sortieStock);
  172.             $sortieStock->setBoutique($this);
  173.         }
  175.         return $this;
  176.     }
  178.     public function removeSortieStock(SortieStock $sortieStock): static
  179.     {
  180.         if ($this->sortieStocks->removeElement($sortieStock)) {
  181.             // set the owning side to null (unless already changed)
  182.             if ($sortieStock->getBoutique() === $this) {
  183.                 $sortieStock->setBoutique(null);
  184.             }
  185.         }
  187.         return $this;
  188.     }
  190.     /**
  191.      * @return Collection<int, Vente>
  192.      */
  193.     public function getVentes(): Collection
  194.     {
  195.         return $this->ventes;
  196.     }
  198.     public function addVente(Vente $vente): static
  199.     {
  200.         if (!$this->ventes->contains($vente)) {
  201.             $this->ventes->add($vente);
  202.             $vente->setBoutique($this);
  203.         }
  205.         return $this;
  206.     }
  208.     public function removeVente(Vente $vente): static
  209.     {
  210.         if ($this->ventes->removeElement($vente)) {
  211.             // set the owning side to null (unless already changed)
  212.             if ($vente->getBoutique() === $this) {
  213.                 $vente->setBoutique(null);
  214.             }
  215.         }
  217.         return $this;
  218.     }
  220.     /**
  221.      * @return Collection<int, EntreeStock>
  222.      */
  223.     public function getEntreeStocks(): Collection
  224.     {
  225.         return $this->entreeStocks;
  226.     }
  228.     public function addEntreeStock(EntreeStock $entreeStock): static
  229.     {
  230.         if (!$this->entreeStocks->contains($entreeStock)) {
  231.             $this->entreeStocks->add($entreeStock);
  232.             $entreeStock->setBoutique($this);
  233.         }
  235.         return $this;
  236.     }
  238.     public function removeEntreeStock(EntreeStock $entreeStock): static
  239.     {
  240.         if ($this->entreeStocks->removeElement($entreeStock)) {
  241.             // set the owning side to null (unless already changed)
  242.             if ($entreeStock->getBoutique() === $this) {
  243.                 $entreeStock->setBoutique(null);
  244.             }
  245.         }
  247.         return $this;
  248.     }
  250.     public function isIsMere(): ?bool
  251.     {
  252.         return $this->isMere;
  253.     }
  255.     public function setIsMere(?bool $isMere): static
  256.     {
  257.         $this->isMere = $isMere;
  259.         return $this;
  260.     }
  262.     /**
  263.      * @return Collection<int, User>
  264.      */
  265.     public function getUsers(): Collection
  266.     {
  267.         return $this->users;
  268.     }
  270.     public function addUser(User $user): static
  271.     {
  272.         if (!$this->users->contains($user)) {
  273.             $this->users->add($user);
  274.             $user->setBoutique($this);
  275.         }
  277.         return $this;
  278.     }
  280.     public function removeUser(User $user): static
  281.     {
  282.         if ($this->users->removeElement($user)) {
  283.             // set the owning side to null (unless already changed)
  284.             if ($user->getBoutique() === $this) {
  285.                 $user->setBoutique(null);
  286.             }
  287.         }
  289.         return $this;
  290.     }
  292.     /**
  293.      * @return Collection<int, Recette>
  294.      */
  295.     public function getRecettes(): Collection
  296.     {
  297.         return $this->recettes;
  298.     }
  300.     public function addRecette(Recette $recette): static
  301.     {
  302.         if (!$this->recettes->contains($recette)) {
  303.             $this->recettes->add($recette);
  304.             $recette->setBoutique($this);
  305.         }
  307.         return $this;
  308.     }
  310.     public function removeRecette(Recette $recette): static
  311.     {
  312.         if ($this->recettes->removeElement($recette)) {
  313.             // set the owning side to null (unless already changed)
  314.             if ($recette->getBoutique() === $this) {
  315.                 $recette->setBoutique(null);
  316.             }
  317.         }
  319.         return $this;
  320.     }
  322.     /**
  323.      * @return Collection<int, Exercice>
  324.      */
  325.     public function getExercices(): Collection
  326.     {
  327.         return $this->exercices;
  328.     }
  330.     public function addExercice(Exercice $exercice): static
  331.     {
  332.         if (!$this->exercices->contains($exercice)) {
  333.             $this->exercices->add($exercice);
  334.             $exercice->setBoutique($this);
  335.         }
  337.         return $this;
  338.     }
  340.     public function removeExercice(Exercice $exercice): static
  341.     {
  342.         if ($this->exercices->removeElement($exercice)) {
  343.             if ($exercice->getBoutique() === $this) {
  344.                 $exercice->setBoutique(null);
  345.             }
  346.         }
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection<int, EcritureComptable>
  353.      */
  354.     public function getEcrituresComptables(): Collection
  355.     {
  356.         return $this->ecrituresComptables;
  357.     }
  359.     public function addEcritureComptable(EcritureComptable $ecritureComptable): static
  360.     {
  361.         if (!$this->ecrituresComptables->contains($ecritureComptable)) {
  362.             $this->ecrituresComptables->add($ecritureComptable);
  363.             $ecritureComptable->setBoutique($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeEcritureComptable(EcritureComptable $ecritureComptable): static
  370.     {
  371.         if ($this->ecrituresComptables->removeElement($ecritureComptable)) {
  372.             if ($ecritureComptable->getBoutique() === $this) {
  373.                 $ecritureComptable->setBoutique(null);
  374.             }
  375.         }
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection<int, Caisse>
  382.      */
  383.     public function getCaisses(): Collection
  384.     {
  385.         return $this->caisses;
  386.     }
  388.     public function addCaisse(Caisse $caisse): static
  389.     {
  390.         if (!$this->caisses->contains($caisse)) {
  391.             $this->caisses->add($caisse);
  392.             $caisse->setBoutique($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeCaisse(Caisse $caisse): static
  399.     {
  400.         if ($this->caisses->removeElement($caisse)) {
  401.             if ($caisse->getBoutique() === $this) {
  402.                 $caisse->setBoutique(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     public function getCaisseOuverte(): ?Caisse
  410.     {
  411.         foreach ($this->caisses as $caisse) {
  412.             if ($caisse->isOuverte()) {
  413.                 return $caisse;
  414.             }
  415.         }
  416.         return null;
  417.     }
  418. }