src/Entity/Institution.php line 21

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Traits\Activeable;
  6. use App\Traits\Creatable;
  7. use App\Traits\Deleteable;
  8. use App\Traits\Updateable;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Gedmo\Mapping\Annotation as Gedmo;
  13. use DateTime;
  14. use DateTimeInterface;
  16. /**
  17.  * @ORM\Table(name="`institution`")
  18.  * @ORM\Entity()
  19.  * @Gedmo\SoftDeleteable(fieldName="deletedAt")
  20.  */
  21. class Institution
  22. {
  23.     use Creatable, Updateable, Deleteable, Activeable;
  25.     /**
  26.      * @ORM\Column(name="id", type="integer")
  27.      * @ORM\Id
  28.      * @ORM\GeneratedValue(strategy="AUTO")
  29.      */
  30.     private ?int $id = null;
  32.     /**
  33.      * @var string
  34.      *
  35.      * @ORM\Column(name="name", type="string")
  36.      */
  37.     private string $name;
  39.     /**
  40.      * @var ?string
  41.      *
  42.      * @ORM\Column(name="url", type="string", nullable=true)
  43.      */
  44.     private ?string $url = null;
  46.     /**
  47.      * @var ?string
  48.      *
  49.      * @ORM\Column(name="phone", type="string", nullable=true)
  50.      */
  51.     private ?string $phone = null;
  53.     /**
  54.      * @var boolean
  55.      *
  56.      * @ORM\Column(name="is_default", type="boolean")
  57.      */
  58.     private bool $isDefault;
  60.     /**
  61.      * @var ?string
  62.      *
  63.      * @ORM\Column(type="string", length=255, nullable=true)
  64.      */
  65.     private ?string $facebook = null;
  67.     /**
  68.      * @var ?string
  69.      *
  70.      * @ORM\Column(type="string", length=255, nullable=true)
  71.      */
  72.     private ?string $instagram = null;
  74.     /**
  75.      * @var ?string
  76.      *
  77.      * @ORM\Column(type="string", length=255, nullable=true)
  78.      */
  79.     private ?string $facebookToken = null;
  81.     /**
  82.      * @var ?string
  83.      *
  84.      * @ORM\Column(type="string", length=255, nullable=true)
  85.      */
  86.     private ?string $senderSms = null;
  88.     /**
  89.      * @var ?string
  90.      *
  91.      * @ORM\Column(name="hash", type="string", nullable=true)
  92.      */
  93.     private ?string $hash = null;
  95.     /**
  96.      * @var ?DateTime
  97.      *
  98.      * @ORM\Column(type="datetime", nullable=true)
  99.      */
  100.     private ?DateTime $qrCodeLastDownloadAt = null;
  102.     /**
  103.      * @ORM\ManyToOne(targetEntity="App\Entity\Document", cascade={"persist"})
  104.      * @ORM\JoinColumn(name="document_id", referencedColumnName="id")
  105.      */
  106.     private ?Document $logo = null;
  108.     /**
  109.      * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="institutions")
  110.      */
  111.     private ?User $user = null;
  113.     /**
  114.      * @ORM\OneToOne(targetEntity="App\Entity\Address", cascade={"persist"})
  115.      */
  116.     private ?Address $address = null;
  118.     /**
  119.      * @ORM\OneToOne(targetEntity="App\Entity\Document", cascade={"persist"})
  120.      */
  121.     private ?Document $qrCode = null;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity="App\Entity\DishCategory", mappedBy="institution", cascade={"remove", "persist"})
  125.      */
  126.     private Collection $dishCategories;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity="App\Entity\WineCategory", mappedBy="institution", cascade={"remove", "persist"})
  130.      */
  131.     private Collection $wineCategories;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity="App\Entity\BeerCategory", mappedBy="institution", cascade={"remove", "persist"})
  135.      */
  136.     private Collection $beerCategories;
  138.     /**
  139.      * @ORM\OneToMany(targetEntity="App\Entity\Dish", mappedBy="institution", cascade={"remove", "persist"})
  140.      * @ORM\OrderBy({"position" = "ASC"})
  141.      */
  142.     private Collection $dishes;
  144.     /**
  145.      * @ORM\OneToMany(targetEntity="App\Entity\Menu", mappedBy="institution", cascade={"remove", "persist"})
  146.      */
  147.     private Collection $menus;
  149.     /**
  150.      * @ORM\OneToMany(targetEntity="App\Entity\MenuCategory", mappedBy="institution", cascade={"remove", "persist"})
  151.      */
  152.     private Collection $menuCategories;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity="App\Entity\Offer", mappedBy="institution", cascade={"remove", "persist"})
  156.      */
  157.     private Collection $offers;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity="App\Entity\Wine", mappedBy="institution", cascade={"remove", "persist"})
  161.      * @ORM\OrderBy({"position" = "ASC"})
  162.      */
  163.     private Collection $wines;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity="App\Entity\DrinkCategory", mappedBy="institution", cascade={"remove", "persist"})
  167.      */
  168.     private Collection $drinkCategories;
  170.     /**
  171.      * @ORM\OneToMany(targetEntity="App\Entity\Drink", mappedBy="institution", cascade={"remove", "persist"})
  172.      * @ORM\OrderBy({"position" = "ASC"})
  173.      */
  174.     private Collection $drinks;
  176.     /**
  177.      * @ORM\OneToMany(targetEntity="App\Entity\Beer", mappedBy="institution", cascade={"remove", "persist"})
  178.      * @ORM\OrderBy({"position" = "ASC"})
  179.      */
  180.     private Collection $beers;
  182.     /**
  183.      * @ORM\OneToMany(targetEntity="App\Entity\Capacity", mappedBy="institution", cascade={"remove", "persist"})
  184.      */
  185.     private Collection $capacities;
  187.     /**
  188.      * @ORM\OneToMany(targetEntity="App\Entity\Creation", mappedBy="institution", cascade={"remove", "persist"})
  189.      * @ORM\OrderBy({"updatedAt" = "DESC"})
  190.      */
  191.     private Collection $creations;
  193.     /**
  194.      * @ORM\OneToMany(targetEntity="App\Entity\CreationCategory", mappedBy="institution", cascade={"remove", "persist"})
  195.      */
  196.     private Collection $creationCategories;
  198.     /**
  199.      * @ORM\OneToMany(targetEntity="App\Entity\WinePairing", mappedBy="institution", cascade={"remove", "persist"})
  200.      */
  201.     private Collection $winePairings;
  203.     /**
  204.      * @ORM\OneToMany(targetEntity="App\Entity\BeerPairing", mappedBy="institution", cascade={"remove", "persist"})
  205.      */
  206.     private Collection $beerPairings;
  208.     /**
  209.      * @ORM\OneToMany(targetEntity="App\Entity\PdfmenuDocument", mappedBy="institution", cascade={"remove", "persist"})
  210.      * @ORM\OrderBy({"position" = "ASC"})
  211.      */
  212.     private Collection $pdfmenuDocuments;
  214.     /**
  215.      * @ORM\OneToOne(targetEntity="App\Entity\PdfmenuPersonalization", mappedBy="institution", cascade={"remove", "persist"})
  216.      */
  217.     private ?PdfmenuPersonalization $pdfmenuPersonalization = null;
  219.     /**
  220.      * @ORM\OneToOne(targetEntity="App\Entity\InstitutionAppPersonalization", mappedBy="institution", cascade={"remove", "persist"})
  221.      */
  222.     private ?InstitutionAppPersonalization $institutionAppPersonalization = null;
  224.     /**
  225.      * @var ?string
  226.      *
  227.      * @ORM\Column(type="text", nullable=true)
  228.      */
  229.     private ?string $description = null;
  231.     /**
  232.      * @ORM\OneToMany(targetEntity="App\Entity\OpeningHour", mappedBy="institution", cascade={"remove", "persist"})
  233.      */
  234.     private Collection $openingHours;
  236.     /**
  237.      * @ORM\OneToMany(targetEntity="App\Entity\Grape", mappedBy="institution", cascade={"remove", "persist"})
  238.      */
  239.     private Collection $grapes;
  241.     /**
  242.      * @var bool
  243.      *
  244.      * @ORM\Column(type="boolean", nullable=true)
  245.      */
  246.     private ?bool $isPdfMenuActive = null;
  248.     /**
  249.      * @ORM\OneToMany(targetEntity="App\Entity\InstitutionLocaleFront", mappedBy="institution", cascade={"remove", "persist"})
  250.      */
  251.     private Collection $institutionLocaleFronts;
  253.     /**
  254.      * @ORM\OneToMany(targetEntity="App\Entity\InstitutionReview", mappedBy="institution", cascade={"remove", "persist"})
  255.      * @ORM\OrderBy({"date" = "DESC"})
  256.      */
  257.     private Collection $institutionReviews;
  259.     /**
  260.      * @ORM\OneToOne(targetEntity="App\Entity\InstitutionReviewSummary", mappedBy="institution", cascade={"remove", "persist"})
  261.      */
  262.     private ?InstitutionReviewSummary $institutionReviewSummary = null;
  264.     /**
  265.      * @ORM\OneToMany(targetEntity="App\Entity\Contest", mappedBy="institution", cascade={"remove", "persist"})
  266.      */
  267.     private Collection $contests;
  269.     /**
  270.      * @ORM\OneToMany(targetEntity="App\Entity\Analysis", mappedBy="institution", cascade={"remove", "persist"})
  271.      */
  272.     private Collection $analyses;
  274.     /**
  275.      * @ORM\OneToMany(targetEntity="App\Entity\Order", mappedBy="institution")
  276.      * @ORM\OrderBy({"createdAt" = "DESC"})
  277.      */
  278.     private Collection $orders;
  280.     /**
  281.      * @ORM\OneToMany(targetEntity="App\Entity\ProductCategoryPosition", mappedBy="institution", cascade={"remove", "persist"})
  282.      */
  283.     private Collection $productCategoryPositions;
  285.     /**
  286.      * @ORM\ManyToMany(targetEntity="App\Entity\Document", cascade={"persist"})
  287.      * @ORM\JoinTable(name="institution_gallery",
  288.      *      joinColumns={@ORM\JoinColumn(name="institution_id", referencedColumnName="id")},
  289.      *      inverseJoinColumns={@ORM\JoinColumn(name="document_id", referencedColumnName="id")}
  290.      *      )
  291.      */
  292.     private Collection $gallery;
  294.     public function __construct()
  295.     {
  296.         $this->isDefault = false;
  297.         $this->dishCategories = new ArrayCollection();
  298.         $this->wineCategories = new ArrayCollection();
  299.         $this->beerCategories = new ArrayCollection();
  300.         $this->menuCategories = new ArrayCollection();
  301.         $this->dishes = new ArrayCollection();
  302.         $this->menus = new ArrayCollection();
  303.         $this->offers = new ArrayCollection();
  304.         $this->wines = new ArrayCollection();
  305.         $this->beers = new ArrayCollection();
  306.         $this->creations = new ArrayCollection();
  307.         $this->creationCategories = new ArrayCollection();
  308.         $this->drinks = new ArrayCollection();
  309.         $this->drinkCategories = new ArrayCollection();
  310.         $this->capacities = new ArrayCollection();
  311.         $this->winePairings = new ArrayCollection();
  312.         $this->beerPairings = new ArrayCollection();
  313.         $this->pdfmenuDocuments = new ArrayCollection();
  314.         $this->openingHours = new ArrayCollection();
  315.         $this->grapes = new ArrayCollection();
  316.         $this->isPdfMenuActive = true;
  317.         $this->institutionLocaleFronts = new ArrayCollection();
  318.         $this->institutionReviews = new ArrayCollection();
  319.         $this->contests = new ArrayCollection();
  320.         $this->analyses = new ArrayCollection();
  321.         $this->orders = new ArrayCollection();
  322.         $this->productCategoryPositions = new ArrayCollection();
  323.         $this->gallery = new ArrayCollection();
  324.     }
  326.     public function getId(): ?int
  327.     {
  328.         return $this->id;
  329.     }
  331.     public function getName(): ?string
  332.     {
  333.         return $this->name;
  334.     }
  336.     public function setName(string $name): self
  337.     {
  338.         $this->name = $name;
  340.         return $this;
  341.     }
  343.     public function getUrl(): ?string
  344.     {
  345.         return $this->url;
  346.     }
  348.     public function setUrl(?string $url): self
  349.     {
  350.         $this->url = $url;
  352.         return $this;
  353.     }
  355.     public function getPhone(): ?string
  356.     {
  357.         return $this->phone;
  358.     }
  360.     public function setPhone(?string $phone): self
  361.     {
  362.         $this->phone = $phone;
  364.         return $this;
  365.     }
  367.     public function isDefault(): ?bool
  368.     {
  369.         return $this->isDefault;
  370.     }
  372.     public function setIsDefault(bool $isDefault): self
  373.     {
  374.         $this->isDefault = $isDefault;
  376.         return $this;
  377.     }
  379.     public function getFacebook(): ?string
  380.     {
  381.         return $this->facebook;
  382.     }
  384.     public function setFacebook(?string $facebook): self
  385.     {
  386.         $this->facebook = $facebook;
  388.         return $this;
  389.     }
  391.     public function getInstagram(): ?string
  392.     {
  393.         return $this->instagram;
  394.     }
  396.     public function setInstagram(?string $instagram): self
  397.     {
  398.         $this->instagram = $instagram;
  400.         return $this;
  401.     }
  403.     public function getFacebookToken(): ?string
  404.     {
  405.         return $this->facebookToken;
  406.     }
  408.     public function setFacebookToken(?string $facebookToken): self
  409.     {
  410.         $this->facebookToken = $facebookToken;
  412.         return $this;
  413.     }
  415.     public function getSenderSms(): ?string
  416.     {
  417.         return $this->senderSms;
  418.     }
  420.     public function setSenderSms(?string $senderSms): self
  421.     {
  422.         $this->senderSms = $senderSms;
  424.         return $this;
  425.     }
  427.     public function getHash(): ?string
  428.     {
  429.         return $this->hash;
  430.     }
  432.     public function setHash(?string $hash): self
  433.     {
  434.         $this->hash = $hash;
  436.         return $this;
  437.     }
  439.     public function getLogo(): ?Document
  440.     {
  441.         return $this->logo;
  442.     }
  444.     public function setLogo(?Document $logo): self
  445.     {
  446.         $this->logo = $logo;
  448.         return $this;
  449.     }
  451.     public function getUser(): ?User
  452.     {
  453.         return $this->user;
  454.     }
  456.     public function setUser(?User $user): self
  457.     {
  458.         $this->user = $user;
  460.         return $this;
  461.     }
  463.     public function getAddress(): ?Address
  464.     {
  465.         return $this->address;
  466.     }
  468.     public function setAddress(?Address $address): self
  469.     {
  470.         $this->address = $address;
  472.         return $this;
  473.     }
  475.     public function getQrCode(): ?Document
  476.     {
  477.         return $this->qrCode;
  478.     }
  480.     public function setQrCode(?Document $qrCode): self
  481.     {
  482.         $this->qrCode = $qrCode;
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection|DishCategory[]
  489.      */
  490.     public function getDishCategories(): array|Collection
  491.     {
  492.         return $this->dishCategories;
  493.     }
  495.     public function addDishCategory(DishCategory $dishCategory): self
  496.     {
  497.         if (!$this->dishCategories->contains($dishCategory)) {
  498.             $this->dishCategories[] = $dishCategory;
  499.             $dishCategory->setInstitution($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeDishCategory(DishCategory $dishCategory): self
  506.     {
  507.         if ($this->dishCategories->contains($dishCategory)) {
  508.             $this->dishCategories->removeElement($dishCategory);
  509.             // set the owning side to null (unless already changed)
  510.             if ($dishCategory->getInstitution() === $this) {
  511.                 $dishCategory->setInstitution(null);
  512.             }
  513.         }
  515.         return $this;
  516.     }
  518.     /**
  519.      * @return Collection|WineCategory[]
  520.      */
  521.     public function getWineCategories(): array|Collection
  522.     {
  523.         return $this->wineCategories;
  524.     }
  526.     public function addWineCategory(WineCategory $wineCategory): self
  527.     {
  528.         if (!$this->wineCategories->contains($wineCategory)) {
  529.             $this->wineCategories[] = $wineCategory;
  530.             $wineCategory->setInstitution($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function removeWineCategory(WineCategory $wineCategory): self
  537.     {
  538.         if ($this->wineCategories->removeElement($wineCategory)) {
  539.             // set the owning side to null (unless already changed)
  540.             if ($wineCategory->getInstitution() === $this) {
  541.                 $wineCategory->setInstitution(null);
  542.             }
  543.         }
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection|BeerCategory[]
  550.      */
  551.     public function getBeerCategories(): array|Collection
  552.     {
  553.         return $this->beerCategories;
  554.     }
  556.     public function addBeerCategory(BeerCategory $beerCategory): self
  557.     {
  558.         if (!$this->beerCategories->contains($beerCategory)) {
  559.             $this->beerCategories[] = $beerCategory;
  560.             $beerCategory->setInstitution($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeBeerCategory(BeerCategory $beerCategory): self
  567.     {
  568.         if ($this->beerCategories->removeElement($beerCategory)) {
  569.             // set the owning side to null (unless already changed)
  570.             if ($beerCategory->getInstitution() === $this) {
  571.                 $beerCategory->setInstitution(null);
  572.             }
  573.         }
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection|Dish[]
  580.      */
  581.     public function getDishes(): array|Collection
  582.     {
  583.         return $this->dishes;
  584.     }
  586.     public function addDish(Dish $dish): self
  587.     {
  588.         if (!$this->dishes->contains($dish)) {
  589.             $this->dishes[] = $dish;
  590.             $dish->setInstitution($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removeDish(Dish $dish): self
  597.     {
  598.         if ($this->dishes->contains($dish)) {
  599.             $this->dishes->removeElement($dish);
  600.             // set the owning side to null (unless already changed)
  601.             if ($dish->getInstitution() === $this) {
  602.                 $dish->setInstitution(null);
  603.             }
  604.         }
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection|Menu[]
  611.      */
  612.     public function getMenus(): array|Collection
  613.     {
  614.         return $this->menus;
  615.     }
  617.     public function addMenu(Menu $menu): self
  618.     {
  619.         if (!$this->menus->contains($menu)) {
  620.             $this->menus[] = $menu;
  621.             $menu->setInstitution($this);
  622.         }
  624.         return $this;
  625.     }
  627.     public function removeMenu(Menu $menu): self
  628.     {
  629.         if ($this->menus->contains($menu)) {
  630.             $this->menus->removeElement($menu);
  631.             // set the owning side to null (unless already changed)
  632.             if ($menu->getInstitution() === $this) {
  633.                 $menu->setInstitution(null);
  634.             }
  635.         }
  637.         return $this;
  638.     }
  640.     /**
  641.      * @return Collection|MenuCategory[]
  642.      */
  643.     public function getMenuCategories(): array|Collection
  644.     {
  645.         return $this->menuCategories;
  646.     }
  648.     public function addMenuCategory(MenuCategory $menuCategory): self
  649.     {
  650.         if (!$this->menuCategories->contains($menuCategory)) {
  651.             $this->menuCategories[] = $menuCategory;
  652.             $menuCategory->setInstitution($this);
  653.         }
  655.         return $this;
  656.     }
  658.     public function removeMenuCategory(MenuCategory $menuCategory): self
  659.     {
  660.         if ($this->menuCategories->removeElement($menuCategory)) {
  661.             // set the owning side to null (unless already changed)
  662.             if ($menuCategory->getInstitution() === $this) {
  663.                 $menuCategory->setInstitution(null);
  664.             }
  665.         }
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection|Offer[]
  672.      */
  673.     public function getOffers(): Collection|array
  674.     {
  675.         return $this->offers;
  676.     }
  678.     public function addOffer(Offer $offer): self
  679.     {
  680.         if (!$this->offers->contains($offer)) {
  681.             $this->offers[] = $offer;
  682.             $offer->setInstitution($this);
  683.         }
  685.         return $this;
  686.     }
  688.     public function removeOffer(Offer $offer): self
  689.     {
  690.         if ($this->offers->removeElement($offer)) {
  691.             // set the owning side to null (unless already changed)
  692.             if ($offer->getInstitution() === $this) {
  693.                 $offer->setInstitution(null);
  694.             }
  695.         }
  697.         return $this;
  698.     }
  700.     /**
  701.      * @return Collection|Wine[]
  702.      */
  703.     public function getWines(): array|Collection
  704.     {
  705.         return $this->wines;
  706.     }
  708.     public function addWine(Wine $wine): self
  709.     {
  710.         if (!$this->wines->contains($wine)) {
  711.             $this->wines[] = $wine;
  712.             $wine->setInstitution($this);
  713.         }
  715.         return $this;
  716.     }
  718.     public function removeWine(Wine $wine): self
  719.     {
  720.         if ($this->wines->contains($wine)) {
  721.             $this->wines->removeElement($wine);
  722.             // set the owning side to null (unless already changed)
  723.             if ($wine->getInstitution() === $this) {
  724.                 $wine->setInstitution(null);
  725.             }
  726.         }
  728.         return $this;
  729.     }
  731.     /**
  732.      * @return Collection|DrinkCategory[]
  733.      */
  734.     public function getDrinkCategories(): Collection|array
  735.     {
  736.         return $this->drinkCategories;
  737.     }
  739.     public function addDrinkCategory(DrinkCategory $drinkCategory): self
  740.     {
  741.         if (!$this->drinkCategories->contains($drinkCategory)) {
  742.             $this->drinkCategories[] = $drinkCategory;
  743.             $drinkCategory->setInstitution($this);
  744.         }
  746.         return $this;
  747.     }
  749.     public function removeDrinkCategory(DrinkCategory $drinkCategory): self
  750.     {
  751.         if ($this->drinkCategories->contains($drinkCategory)) {
  752.             $this->drinkCategories->removeElement($drinkCategory);
  753.             // set the owning side to null (unless already changed)
  754.             if ($drinkCategory->getInstitution() === $this) {
  755.                 $drinkCategory->setInstitution(null);
  756.             }
  757.         }
  759.         return $this;
  760.     }
  762.     /**
  763.      * @return Collection|Drink[]
  764.      */
  765.     public function getDrinks(): Collection|array
  766.     {
  767.         return $this->drinks;
  768.     }
  770.     public function addDrink(Drink $drink): self
  771.     {
  772.         if (!$this->drinks->contains($drink)) {
  773.             $this->drinks[] = $drink;
  774.             $drink->setInstitution($this);
  775.         }
  777.         return $this;
  778.     }
  780.     public function removeDrink(Drink $drink): self
  781.     {
  782.         if ($this->drinks->contains($drink)) {
  783.             $this->drinks->removeElement($drink);
  784.             // set the owning side to null (unless already changed)
  785.             if ($drink->getInstitution() === $this) {
  786.                 $drink->setInstitution(null);
  787.             }
  788.         }
  790.         return $this;
  791.     }
  793.     /**
  794.      * @return Collection|Beer[]
  795.      */
  796.     public function getBeers(): array|Collection
  797.     {
  798.         return $this->beers;
  799.     }
  801.     public function addBeer(Beer $beer): self
  802.     {
  803.         if (!$this->beers->contains($beer)) {
  804.             $this->beers[] = $beer;
  805.             $beer->setInstitution($this);
  806.         }
  808.         return $this;
  809.     }
  811.     public function removeBeer(Beer $beer): self
  812.     {
  813.         if ($this->beers->contains($beer)) {
  814.             $this->beers->removeElement($beer);
  815.             // set the owning side to null (unless already changed)
  816.             if ($beer->getInstitution() === $this) {
  817.                 $beer->setInstitution(null);
  818.             }
  819.         }
  821.         return $this;
  822.     }
  824.     /**
  825.      * @return Collection|Capacity[]
  826.      */
  827.     public function getCapacities(): Collection|array
  828.     {
  829.         return $this->capacities;
  830.     }
  832.     public function addCapacity(Capacity $capacity): self
  833.     {
  834.         if (!$this->capacities->contains($capacity)) {
  835.             $this->capacities[] = $capacity;
  836.             $capacity->setInstitution($this);
  837.         }
  839.         return $this;
  840.     }
  842.     public function removeCapacity(Capacity $capacity): self
  843.     {
  844.         if ($this->capacities->contains($capacity)) {
  845.             $this->capacities->removeElement($capacity);
  846.             // set the owning side to null (unless already changed)
  847.             if ($capacity->getInstitution() === $this) {
  848.                 $capacity->setInstitution(null);
  849.             }
  850.         }
  852.         return $this;
  853.     }
  855.     /**
  856.      * @return Collection|Creation[]
  857.      */
  858.     public function getCreations(): Collection|array
  859.     {
  860.         return $this->creations;
  861.     }
  863.     public function addCreation(Creation $creation): self
  864.     {
  865.         if (!$this->creations->contains($creation)) {
  866.             $this->creations[] = $creation;
  867.             $creation->setInstitution($this);
  868.         }
  870.         return $this;
  871.     }
  873.     public function removeCreation(Creation $creation): self
  874.     {
  875.         if ($this->creations->contains($creation)) {
  876.             $this->creations->removeElement($creation);
  877.             // set the owning side to null (unless already changed)
  878.             if ($creation->getInstitution() === $this) {
  879.                 $creation->setInstitution(null);
  880.             }
  881.         }
  883.         return $this;
  884.     }
  886.     /**
  887.      * @return Collection|CreationCategory[]
  888.      */
  889.     public function getCreationCategories(): Collection|array
  890.     {
  891.         return $this->creationCategories;
  892.     }
  894.     public function addCreationCategory(CreationCategory $creationCategory): self
  895.     {
  896.         if (!$this->creationCategories->contains($creationCategory)) {
  897.             $this->creationCategories[] = $creationCategory;
  898.             $creationCategory->setInstitution($this);
  899.         }
  901.         return $this;
  902.     }
  904.     public function removeCreationCategory(CreationCategory $creationCategory): self
  905.     {
  906.         if ($this->creationCategories->contains($creationCategory)) {
  907.             $this->creationCategories->removeElement($creationCategory);
  908.             // set the owning side to null (unless already changed)
  909.             if ($creationCategory->getInstitution() === $this) {
  910.                 $creationCategory->setInstitution(null);
  911.             }
  912.         }
  914.         return $this;
  915.     }
  917.     public function getIsDefault(): ?bool
  918.     {
  919.         return $this->isDefault;
  920.     }
  922.     /**
  923.      * @return Collection|WinePairing[]
  924.      */
  925.     public function getWinePairings(): array|Collection
  926.     {
  927.         return $this->winePairings;
  928.     }
  930.     public function addWinePairing(WinePairing $winePairing): self
  931.     {
  932.         if (!$this->winePairings->contains($winePairing)) {
  933.             $this->winePairings[] = $winePairing;
  934.             $winePairing->setInstitution($this);
  935.         }
  937.         return $this;
  938.     }
  940.     public function removeWinePairing(WinePairing $winePairing): self
  941.     {
  942.         if ($this->winePairings->contains($winePairing)) {
  943.             $this->winePairings->removeElement($winePairing);
  944.             // set the owning side to null (unless already changed)
  945.             if ($winePairing->getInstitution() === $this) {
  946.                 $winePairing->setInstitution(null);
  947.             }
  948.         }
  950.         return $this;
  951.     }
  953.     /**
  954.      * @return Collection|BeerPairing[]
  955.      */
  956.     public function getBeerPairings(): array|Collection
  957.     {
  958.         return $this->beerPairings;
  959.     }
  961.     public function addBeerPairing(BeerPairing $beerPairing): self
  962.     {
  963.         if (!$this->beerPairings->contains($beerPairing)) {
  964.             $this->beerPairings[] = $beerPairing;
  965.             $beerPairing->setInstitution($this);
  966.         }
  968.         return $this;
  969.     }
  971.     public function removeBeerPairing(BeerPairing $beerPairing): self
  972.     {
  973.         if ($this->beerPairings->contains($beerPairing)) {
  974.             $this->beerPairings->removeElement($beerPairing);
  975.             // set the owning side to null (unless already changed)
  976.             if ($beerPairing->getInstitution() === $this) {
  977.                 $beerPairing->setInstitution(null);
  978.             }
  979.         }
  981.         return $this;
  982.     }
  984.     /**
  985.      * @return Collection|PdfmenuDocument[]
  986.      */
  987.     public function getPdfmenuDocuments(): array|Collection
  988.     {
  989.         return $this->pdfmenuDocuments;
  990.     }
  992.     public function addPdfmenuDocument(PdfmenuDocument $pdfmenuDocument): self
  993.     {
  994.         if (!$this->pdfmenuDocuments->contains($pdfmenuDocument)) {
  995.             $this->pdfmenuDocuments[] = $pdfmenuDocument;
  996.             $pdfmenuDocument->setInstitution($this);
  997.         }
  999.         return $this;
  1000.     }
  1002.     public function removePdfmenuDocument(PdfmenuDocument $pdfmenuDocument): self
  1003.     {
  1004.         if ($this->pdfmenuDocuments->contains($pdfmenuDocument)) {
  1005.             $this->pdfmenuDocuments->removeElement($pdfmenuDocument);
  1006.             // set the owning side to null (unless already changed)
  1007.             if ($pdfmenuDocument->getInstitution() === $this) {
  1008.                 $pdfmenuDocument->setInstitution(null);
  1009.             }
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function getPdfmenuPersonalization(): ?PdfmenuPersonalization
  1016.     {
  1017.         return $this->pdfmenuPersonalization;
  1018.     }
  1020.     public function setPdfmenuPersonalization(?PdfmenuPersonalization $pdfmenuPersonalization): self
  1021.     {
  1022.         $this->pdfmenuPersonalization = $pdfmenuPersonalization;
  1024.         // set (or unset) the owning side of the relation if necessary
  1025.         $newInstitution = null === $pdfmenuPersonalization ? null : $this;
  1026.         if ($pdfmenuPersonalization->getInstitution() !== $newInstitution) {
  1027.             $pdfmenuPersonalization->setInstitution($newInstitution);
  1028.         }
  1030.         return $this;
  1031.     }
  1033.     public function getInstitutionAppPersonalization(): ?InstitutionAppPersonalization
  1034.     {
  1035.         return $this->institutionAppPersonalization;
  1036.     }
  1038.     public function setInstitutionAppPersonalization(?InstitutionAppPersonalization $institutionAppPersonalization): self
  1039.     {
  1040.         $this->institutionAppPersonalization = $institutionAppPersonalization;
  1042.         // set (or unset) the owning side of the relation if necessary
  1043.         $newInstitution = null === $institutionAppPersonalization ? null : $this;
  1044.         if ($institutionAppPersonalization->getInstitution() !== $newInstitution) {
  1045.             $institutionAppPersonalization->setInstitution($newInstitution);
  1046.         }
  1048.         return $this;
  1049.     }
  1051.     public function getDescription(): ?string
  1052.     {
  1053.         return $this->description;
  1054.     }
  1056.     public function setDescription(?string $description): self
  1057.     {
  1058.         $this->description = $description;
  1060.         return $this;
  1061.     }
  1063.     /**
  1064.      * @return Collection|OpeningHour[]
  1065.      */
  1066.     public function getOpeningHours(): array|Collection
  1067.     {
  1068.         return $this->openingHours;
  1069.     }
  1071.     public function addOpeningHour(OpeningHour $openingHour): self
  1072.     {
  1073.         if (!$this->openingHours->contains($openingHour)) {
  1074.             $this->openingHours[] = $openingHour;
  1075.             $openingHour->setInstitution($this);
  1076.         }
  1078.         return $this;
  1079.     }
  1081.     public function removeOpeningHour(OpeningHour $openingHour): self
  1082.     {
  1083.         if ($this->openingHours->removeElement($openingHour)) {
  1084.             // set the owning side to null (unless already changed)
  1085.             if ($openingHour->getInstitution() === $this) {
  1086.                 $openingHour->setInstitution(null);
  1087.             }
  1088.         }
  1090.         return $this;
  1091.     }
  1093.     /**
  1094.      * @return Collection|Grape[]
  1095.      */
  1096.     public function getGrapes(): Collection|array
  1097.     {
  1098.         return $this->grapes;
  1099.     }
  1101.     public function addGrape(Grape $grape): self
  1102.     {
  1103.         if (!$this->grapes->contains($grape)) {
  1104.             $this->grapes[] = $grape;
  1105.             $grape->setInstitution($this);
  1106.         }
  1108.         return $this;
  1109.     }
  1111.     public function removeGrape(Grape $grape): self
  1112.     {
  1113.         if ($this->grapes->contains($grape)) {
  1114.             $this->grapes->removeElement($grape);
  1115.             // set the owning side to null (unless already changed)
  1116.             if ($grape->getInstitution() === $this) {
  1117.                 $grape->setInstitution(null);
  1118.             }
  1119.         }
  1121.         return $this;
  1122.     }
  1124.     public function getIsPdfMenuActive(): ?bool
  1125.     {
  1126.         return $this->isPdfMenuActive;
  1127.     }
  1129.     public function setIsPdfMenuActive(?bool $isPdfMenuActive): self
  1130.     {
  1131.         $this->isPdfMenuActive = $isPdfMenuActive;
  1133.         return $this;
  1134.     }
  1136.     /**
  1137.      * @return Collection|InstitutionLocaleFront[]
  1138.      */
  1139.     public function getInstitutionLocaleFronts(): Collection|array
  1140.     {
  1141.         return $this->institutionLocaleFronts;
  1142.     }
  1144.     public function addInstitutionLocaleFront(InstitutionLocaleFront $institutionLocaleFront): self
  1145.     {
  1146.         if (!$this->institutionLocaleFronts->contains($institutionLocaleFront)) {
  1147.             $this->institutionLocaleFronts[] = $institutionLocaleFront;
  1148.             $institutionLocaleFront->setInstitution($this);
  1149.         }
  1151.         return $this;
  1152.     }
  1154.     public function removeInstitutionLocaleFront(InstitutionLocaleFront $institutionLocaleFront): self
  1155.     {
  1156.         if ($this->institutionLocaleFronts->removeElement($institutionLocaleFront)) {
  1157.             // set the owning side to null (unless already changed)
  1158.             if ($institutionLocaleFront->getInstitution() === $this) {
  1159.                 $institutionLocaleFront->setInstitution(null);
  1160.             }
  1161.         }
  1163.         return $this;
  1164.     }
  1166.     /**
  1167.      * @return ArrayCollection
  1168.      */
  1169.     public function getActiveDishes(): ArrayCollection
  1170.     {
  1171.         $collections = new ArrayCollection();
  1173.         foreach ($this->getDishes() as $dish) {
  1174.             if ($dish->isActive()) {
  1175.                 if (!$collections->contains($dish)) {
  1176.                     $collections->add($dish);
  1177.                 }
  1178.             }
  1179.         }
  1181.         return $collections;
  1182.     }
  1184.     /**
  1185.      * @return ArrayCollection
  1186.      */
  1187.     public function getActiveWines(): ArrayCollection
  1188.     {
  1189.         $collections = new ArrayCollection();
  1191.         foreach ($this->getWines() as $wine) {
  1192.             if ($wine->isActive()) {
  1193.                 if (!$collections->contains($wine)) {
  1194.                     $collections->add($wine);
  1195.                 }
  1196.             }
  1197.         }
  1199.         return $collections;
  1200.     }
  1202.     /**
  1203.      * @return ArrayCollection
  1204.      */
  1205.     public function getActiveBeers(): ArrayCollection
  1206.     {
  1207.         $collections = new ArrayCollection();
  1209.         foreach ($this->getBeers() as $beer) {
  1210.             if ($beer->isActive()) {
  1211.                 if (!$collections->contains($beer)) {
  1212.                     $collections->add($beer);
  1213.                 }
  1214.             }
  1215.         }
  1217.         return $collections;
  1218.     }
  1220.     /**
  1221.      * @return ArrayCollection
  1222.      */
  1223.     public function getActiveDrinks(): ArrayCollection
  1224.     {
  1225.         $collections = new ArrayCollection();
  1227.         foreach ($this->getDrinks() as $drink) {
  1228.             if ($drink->isActive()) {
  1229.                 if (!$collections->contains($drink)) {
  1230.                     $collections->add($drink);
  1231.                 }
  1232.             }
  1233.         }
  1235.         return $collections;
  1236.     }
  1238.     /**
  1239.      * @return Collection|InstitutionReview[]
  1240.      */
  1241.     public function getInstitutionReviews(): Collection|array
  1242.     {
  1243.         return $this->institutionReviews;
  1244.     }
  1246.     public function addInstitutionReview(InstitutionReview $institutionReview): self
  1247.     {
  1248.         if (!$this->institutionReviews->contains($institutionReview)) {
  1249.             $this->institutionReviews[] = $institutionReview;
  1250.             $institutionReview->setInstitution($this);
  1251.         }
  1253.         return $this;
  1254.     }
  1256.     public function removeInstitutionReview(InstitutionReview $institutionReview): self
  1257.     {
  1258.         if ($this->institutionReviews->removeElement($institutionReview)) {
  1259.             // set the owning side to null (unless already changed)
  1260.             if ($institutionReview->getInstitution() === $this) {
  1261.                 $institutionReview->setInstitution(null);
  1262.             }
  1263.         }
  1265.         return $this;
  1266.     }
  1268.     public function getInstitutionReviewSummary(): ?InstitutionReviewSummary
  1269.     {
  1270.         return $this->institutionReviewSummary;
  1271.     }
  1273.     public function setInstitutionReviewSummary(?InstitutionReviewSummary $institutionReviewSummary): self
  1274.     {
  1275.         $this->institutionReviewSummary = $institutionReviewSummary;
  1277.         // set (or unset) the owning side of the relation if necessary
  1278.         $newInstitution = null === $institutionReviewSummary ? null : $this;
  1279.         if ($institutionReviewSummary->getInstitution() !== $newInstitution) {
  1280.             $institutionReviewSummary->setInstitution($newInstitution);
  1281.         }
  1283.         return $this;
  1284.     }
  1286.     /**
  1287.      * @return Collection|Contest[]
  1288.      */
  1289.     public function getContests(): Collection|array
  1290.     {
  1291.         return $this->contests;
  1292.     }
  1294.     public function addContest(Contest $contest): self
  1295.     {
  1296.         if (!$this->contests->contains($contest)) {
  1297.             $this->contests[] = $contest;
  1298.             $contest->setInstitution($this);
  1299.         }
  1301.         return $this;
  1302.     }
  1304.     public function removeContest(Contest $contest): self
  1305.     {
  1306.         if ($this->contests->removeElement($contest)) {
  1307.             // set the owning side to null (unless already changed)
  1308.             if ($contest->getInstitution() === $this) {
  1309.                 $contest->setInstitution(null);
  1310.             }
  1311.         }
  1313.         return $this;
  1314.     }
  1316.     /**
  1317.      * @return Collection|Analysis[]
  1318.      */
  1319.     public function getAnalyses(): array|Collection
  1320.     {
  1321.         return $this->analyses;
  1322.     }
  1324.     public function addAnalysis(Analysis $analysis): self
  1325.     {
  1326.         if (!$this->analyses->contains($analysis)) {
  1327.             $this->analyses[] = $analysis;
  1328.             $analysis->setInstitution($this);
  1329.         }
  1331.         return $this;
  1332.     }
  1334.     public function removeAnalysis(Analysis $analysis): self
  1335.     {
  1336.         if ($this->analyses->removeElement($analysis)) {
  1337.             // set the owning side to null (unless already changed)
  1338.             if ($analysis->getInstitution() === $this) {
  1339.                 $analysis->setInstitution(null);
  1340.             }
  1341.         }
  1343.         return $this;
  1344.     }
  1346.     /**
  1347.      * @return Collection|Order[]
  1348.      */
  1349.     public function getOrders(): Collection|array
  1350.     {
  1351.         return $this->orders;
  1352.     }
  1354.     public function addOrder(Order $order): self
  1355.     {
  1356.         if (!$this->orders->contains($order)) {
  1357.             $this->orders[] = $order;
  1358.             $order->setInstitution($this);
  1359.         }
  1361.         return $this;
  1362.     }
  1364.     public function removeOrder(Order $order): self
  1365.     {
  1366.         if ($this->orders->removeElement($order)) {
  1367.             // set the owning side to null (unless already changed)
  1368.             if ($order->getInstitution() === $this) {
  1369.                 $order->setInstitution(null);
  1370.             }
  1371.         }
  1373.         return $this;
  1374.     }
  1376.     /**
  1377.      * @return Collection|ProductCategoryPosition[]
  1378.      */
  1379.     public function getProductCategoryPositions(): array|Collection
  1380.     {
  1381.         return $this->productCategoryPositions;
  1382.     }
  1384.     public function addProductCategoryPosition(ProductCategoryPosition $productCategoryPosition): self
  1385.     {
  1386.         if (!$this->productCategoryPositions->contains($productCategoryPosition)) {
  1387.             $this->productCategoryPositions[] = $productCategoryPosition;
  1388.             $productCategoryPosition->setInstitution($this);
  1389.         }
  1391.         return $this;
  1392.     }
  1394.     public function removeProductCategoryPosition(ProductCategoryPosition $productCategoryPosition): self
  1395.     {
  1396.         if ($this->productCategoryPositions->removeElement($productCategoryPosition)) {
  1397.             // set the owning side to null (unless already changed)
  1398.             if ($productCategoryPosition->getInstitution() === $this) {
  1399.                 $productCategoryPosition->setInstitution(null);
  1400.             }
  1401.         }
  1403.         return $this;
  1404.     }
  1406.     /**
  1407.      * @return Collection|Document[]
  1408.      */
  1409.     public function getGallery(): Collection|array
  1410.     {
  1411.         return $this->gallery;
  1412.     }
  1414.     public function addImageToGallery(Document $document): self
  1415.     {
  1416.         if (!$this->gallery->contains($document)) {
  1417.             $this->gallery[] = $document;
  1418.         }
  1420.         return $this;
  1421.     }
  1423.     public function removeImageFromGallery(Document $document): self
  1424.     {
  1425.         $this->gallery->removeElement($document);
  1427.         return $this;
  1428.     }
  1430.     public function resetGallery(): self
  1431.     {
  1432.         $this->gallery->clear();
  1434.         return $this;
  1435.     }
  1437.     public function getQrCodeLastDownloadAt(): ?DateTimeInterface
  1438.     {
  1439.         return $this->qrCodeLastDownloadAt;
  1440.     }
  1442.     public function setQrCodeLastDownloadAt(?DateTimeInterface $qrCodeLastDownloadAt): self
  1443.     {
  1444.         $this->qrCodeLastDownloadAt = $qrCodeLastDownloadAt;
  1446.         return $this;
  1447.     }
  1449.     public function addGallery(Document $gallery): self
  1450.     {
  1451.         if (!$this->gallery->contains($gallery)) {
  1452.             $this->gallery[] = $gallery;
  1453.         }
  1455.         return $this;
  1456.     }
  1458.     public function removeGallery(Document $gallery): self
  1459.     {
  1460.         $this->gallery->removeElement($gallery);
  1462.         return $this;
  1463.     }
  1464. }