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.     /**
  295.      * @ORM\ManyToOne(targetEntity="App\Entity\Currency", inversedBy="institutions")
  296.      * @ORM\JoinColumn(name="currency_id", referencedColumnName="id", nullable=true)
  297.      */
  298.     private ?Currency $institutionCurrency = null;
  300.     public function __construct()
  301.     {
  302.         $this->isDefault = false;
  303.         $this->dishCategories = new ArrayCollection();
  304.         $this->wineCategories = new ArrayCollection();
  305.         $this->beerCategories = new ArrayCollection();
  306.         $this->menuCategories = new ArrayCollection();
  307.         $this->dishes = new ArrayCollection();
  308.         $this->menus = new ArrayCollection();
  309.         $this->offers = new ArrayCollection();
  310.         $this->wines = new ArrayCollection();
  311.         $this->beers = new ArrayCollection();
  312.         $this->creations = new ArrayCollection();
  313.         $this->creationCategories = new ArrayCollection();
  314.         $this->drinks = new ArrayCollection();
  315.         $this->drinkCategories = new ArrayCollection();
  316.         $this->capacities = new ArrayCollection();
  317.         $this->winePairings = new ArrayCollection();
  318.         $this->beerPairings = new ArrayCollection();
  319.         $this->pdfmenuDocuments = new ArrayCollection();
  320.         $this->openingHours = new ArrayCollection();
  321.         $this->grapes = new ArrayCollection();
  322.         $this->isPdfMenuActive = true;
  323.         $this->institutionLocaleFronts = new ArrayCollection();
  324.         $this->institutionReviews = new ArrayCollection();
  325.         $this->contests = new ArrayCollection();
  326.         $this->analyses = new ArrayCollection();
  327.         $this->orders = new ArrayCollection();
  328.         $this->productCategoryPositions = new ArrayCollection();
  329.         $this->gallery = new ArrayCollection();
  330.     }
  332.     public function getId(): ?int
  333.     {
  334.         return $this->id;
  335.     }
  337.     public function getName(): ?string
  338.     {
  339.         return $this->name;
  340.     }
  342.     public function setName(string $name): self
  343.     {
  344.         $this->name = $name;
  346.         return $this;
  347.     }
  349.     public function getUrl(): ?string
  350.     {
  351.         return $this->url;
  352.     }
  354.     public function setUrl(?string $url): self
  355.     {
  356.         $this->url = $url;
  358.         return $this;
  359.     }
  361.     public function getPhone(): ?string
  362.     {
  363.         return $this->phone;
  364.     }
  366.     public function setPhone(?string $phone): self
  367.     {
  368.         $this->phone = $phone;
  370.         return $this;
  371.     }
  373.     public function isDefault(): ?bool
  374.     {
  375.         return $this->isDefault;
  376.     }
  378.     public function setIsDefault(bool $isDefault): self
  379.     {
  380.         $this->isDefault = $isDefault;
  382.         return $this;
  383.     }
  385.     public function getFacebook(): ?string
  386.     {
  387.         return $this->facebook;
  388.     }
  390.     public function setFacebook(?string $facebook): self
  391.     {
  392.         $this->facebook = $facebook;
  394.         return $this;
  395.     }
  397.     public function getInstagram(): ?string
  398.     {
  399.         return $this->instagram;
  400.     }
  402.     public function setInstagram(?string $instagram): self
  403.     {
  404.         $this->instagram = $instagram;
  406.         return $this;
  407.     }
  409.     public function getFacebookToken(): ?string
  410.     {
  411.         return $this->facebookToken;
  412.     }
  414.     public function setFacebookToken(?string $facebookToken): self
  415.     {
  416.         $this->facebookToken = $facebookToken;
  418.         return $this;
  419.     }
  421.     public function getSenderSms(): ?string
  422.     {
  423.         return $this->senderSms;
  424.     }
  426.     public function setSenderSms(?string $senderSms): self
  427.     {
  428.         $this->senderSms = $senderSms;
  430.         return $this;
  431.     }
  433.     public function getHash(): ?string
  434.     {
  435.         return $this->hash;
  436.     }
  438.     public function setHash(?string $hash): self
  439.     {
  440.         $this->hash = $hash;
  442.         return $this;
  443.     }
  445.     public function getLogo(): ?Document
  446.     {
  447.         return $this->logo;
  448.     }
  450.     public function setLogo(?Document $logo): self
  451.     {
  452.         $this->logo = $logo;
  454.         return $this;
  455.     }
  457.     public function getUser(): ?User
  458.     {
  459.         return $this->user;
  460.     }
  462.     public function setUser(?User $user): self
  463.     {
  464.         $this->user = $user;
  466.         return $this;
  467.     }
  469.     public function getAddress(): ?Address
  470.     {
  471.         return $this->address;
  472.     }
  474.     public function setAddress(?Address $address): self
  475.     {
  476.         $this->address = $address;
  478.         return $this;
  479.     }
  481.     public function getQrCode(): ?Document
  482.     {
  483.         return $this->qrCode;
  484.     }
  486.     public function setQrCode(?Document $qrCode): self
  487.     {
  488.         $this->qrCode = $qrCode;
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return Collection|DishCategory[]
  495.      */
  496.     public function getDishCategories(): array|Collection
  497.     {
  498.         return $this->dishCategories;
  499.     }
  501.     public function addDishCategory(DishCategory $dishCategory): self
  502.     {
  503.         if (!$this->dishCategories->contains($dishCategory)) {
  504.             $this->dishCategories[] = $dishCategory;
  505.             $dishCategory->setInstitution($this);
  506.         }
  508.         return $this;
  509.     }
  511.     public function removeDishCategory(DishCategory $dishCategory): self
  512.     {
  513.         if ($this->dishCategories->contains($dishCategory)) {
  514.             $this->dishCategories->removeElement($dishCategory);
  515.             // set the owning side to null (unless already changed)
  516.             if ($dishCategory->getInstitution() === $this) {
  517.                 $dishCategory->setInstitution(null);
  518.             }
  519.         }
  521.         return $this;
  522.     }
  524.     /**
  525.      * @return Collection|WineCategory[]
  526.      */
  527.     public function getWineCategories(): array|Collection
  528.     {
  529.         return $this->wineCategories;
  530.     }
  532.     public function addWineCategory(WineCategory $wineCategory): self
  533.     {
  534.         if (!$this->wineCategories->contains($wineCategory)) {
  535.             $this->wineCategories[] = $wineCategory;
  536.             $wineCategory->setInstitution($this);
  537.         }
  539.         return $this;
  540.     }
  542.     public function removeWineCategory(WineCategory $wineCategory): self
  543.     {
  544.         if ($this->wineCategories->removeElement($wineCategory)) {
  545.             // set the owning side to null (unless already changed)
  546.             if ($wineCategory->getInstitution() === $this) {
  547.                 $wineCategory->setInstitution(null);
  548.             }
  549.         }
  551.         return $this;
  552.     }
  554.     /**
  555.      * @return Collection|BeerCategory[]
  556.      */
  557.     public function getBeerCategories(): array|Collection
  558.     {
  559.         return $this->beerCategories;
  560.     }
  562.     public function addBeerCategory(BeerCategory $beerCategory): self
  563.     {
  564.         if (!$this->beerCategories->contains($beerCategory)) {
  565.             $this->beerCategories[] = $beerCategory;
  566.             $beerCategory->setInstitution($this);
  567.         }
  569.         return $this;
  570.     }
  572.     public function removeBeerCategory(BeerCategory $beerCategory): self
  573.     {
  574.         if ($this->beerCategories->removeElement($beerCategory)) {
  575.             // set the owning side to null (unless already changed)
  576.             if ($beerCategory->getInstitution() === $this) {
  577.                 $beerCategory->setInstitution(null);
  578.             }
  579.         }
  581.         return $this;
  582.     }
  584.     /**
  585.      * @return Collection|Dish[]
  586.      */
  587.     public function getDishes(): array|Collection
  588.     {
  589.         return $this->dishes;
  590.     }
  592.     public function addDish(Dish $dish): self
  593.     {
  594.         if (!$this->dishes->contains($dish)) {
  595.             $this->dishes[] = $dish;
  596.             $dish->setInstitution($this);
  597.         }
  599.         return $this;
  600.     }
  602.     public function removeDish(Dish $dish): self
  603.     {
  604.         if ($this->dishes->contains($dish)) {
  605.             $this->dishes->removeElement($dish);
  606.             // set the owning side to null (unless already changed)
  607.             if ($dish->getInstitution() === $this) {
  608.                 $dish->setInstitution(null);
  609.             }
  610.         }
  612.         return $this;
  613.     }
  615.     /**
  616.      * @return Collection|Menu[]
  617.      */
  618.     public function getMenus(): array|Collection
  619.     {
  620.         return $this->menus;
  621.     }
  623.     public function addMenu(Menu $menu): self
  624.     {
  625.         if (!$this->menus->contains($menu)) {
  626.             $this->menus[] = $menu;
  627.             $menu->setInstitution($this);
  628.         }
  630.         return $this;
  631.     }
  633.     public function removeMenu(Menu $menu): self
  634.     {
  635.         if ($this->menus->contains($menu)) {
  636.             $this->menus->removeElement($menu);
  637.             // set the owning side to null (unless already changed)
  638.             if ($menu->getInstitution() === $this) {
  639.                 $menu->setInstitution(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection|MenuCategory[]
  648.      */
  649.     public function getMenuCategories(): array|Collection
  650.     {
  651.         return $this->menuCategories;
  652.     }
  654.     public function addMenuCategory(MenuCategory $menuCategory): self
  655.     {
  656.         if (!$this->menuCategories->contains($menuCategory)) {
  657.             $this->menuCategories[] = $menuCategory;
  658.             $menuCategory->setInstitution($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removeMenuCategory(MenuCategory $menuCategory): self
  665.     {
  666.         if ($this->menuCategories->removeElement($menuCategory)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($menuCategory->getInstitution() === $this) {
  669.                 $menuCategory->setInstitution(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  676.     /**
  677.      * @return Collection|Offer[]
  678.      */
  679.     public function getOffers(): Collection|array
  680.     {
  681.         return $this->offers;
  682.     }
  684.     public function addOffer(Offer $offer): self
  685.     {
  686.         if (!$this->offers->contains($offer)) {
  687.             $this->offers[] = $offer;
  688.             $offer->setInstitution($this);
  689.         }
  691.         return $this;
  692.     }
  694.     public function removeOffer(Offer $offer): self
  695.     {
  696.         if ($this->offers->removeElement($offer)) {
  697.             // set the owning side to null (unless already changed)
  698.             if ($offer->getInstitution() === $this) {
  699.                 $offer->setInstitution(null);
  700.             }
  701.         }
  703.         return $this;
  704.     }
  706.     /**
  707.      * @return Collection|Wine[]
  708.      */
  709.     public function getWines(): array|Collection
  710.     {
  711.         return $this->wines;
  712.     }
  714.     public function addWine(Wine $wine): self
  715.     {
  716.         if (!$this->wines->contains($wine)) {
  717.             $this->wines[] = $wine;
  718.             $wine->setInstitution($this);
  719.         }
  721.         return $this;
  722.     }
  724.     public function removeWine(Wine $wine): self
  725.     {
  726.         if ($this->wines->contains($wine)) {
  727.             $this->wines->removeElement($wine);
  728.             // set the owning side to null (unless already changed)
  729.             if ($wine->getInstitution() === $this) {
  730.                 $wine->setInstitution(null);
  731.             }
  732.         }
  734.         return $this;
  735.     }
  737.     /**
  738.      * @return Collection|DrinkCategory[]
  739.      */
  740.     public function getDrinkCategories(): Collection|array
  741.     {
  742.         return $this->drinkCategories;
  743.     }
  745.     public function addDrinkCategory(DrinkCategory $drinkCategory): self
  746.     {
  747.         if (!$this->drinkCategories->contains($drinkCategory)) {
  748.             $this->drinkCategories[] = $drinkCategory;
  749.             $drinkCategory->setInstitution($this);
  750.         }
  752.         return $this;
  753.     }
  755.     public function removeDrinkCategory(DrinkCategory $drinkCategory): self
  756.     {
  757.         if ($this->drinkCategories->contains($drinkCategory)) {
  758.             $this->drinkCategories->removeElement($drinkCategory);
  759.             // set the owning side to null (unless already changed)
  760.             if ($drinkCategory->getInstitution() === $this) {
  761.                 $drinkCategory->setInstitution(null);
  762.             }
  763.         }
  765.         return $this;
  766.     }
  768.     /**
  769.      * @return Collection|Drink[]
  770.      */
  771.     public function getDrinks(): Collection|array
  772.     {
  773.         return $this->drinks;
  774.     }
  776.     public function addDrink(Drink $drink): self
  777.     {
  778.         if (!$this->drinks->contains($drink)) {
  779.             $this->drinks[] = $drink;
  780.             $drink->setInstitution($this);
  781.         }
  783.         return $this;
  784.     }
  786.     public function removeDrink(Drink $drink): self
  787.     {
  788.         if ($this->drinks->contains($drink)) {
  789.             $this->drinks->removeElement($drink);
  790.             // set the owning side to null (unless already changed)
  791.             if ($drink->getInstitution() === $this) {
  792.                 $drink->setInstitution(null);
  793.             }
  794.         }
  796.         return $this;
  797.     }
  799.     /**
  800.      * @return Collection|Beer[]
  801.      */
  802.     public function getBeers(): array|Collection
  803.     {
  804.         return $this->beers;
  805.     }
  807.     public function addBeer(Beer $beer): self
  808.     {
  809.         if (!$this->beers->contains($beer)) {
  810.             $this->beers[] = $beer;
  811.             $beer->setInstitution($this);
  812.         }
  814.         return $this;
  815.     }
  817.     public function removeBeer(Beer $beer): self
  818.     {
  819.         if ($this->beers->contains($beer)) {
  820.             $this->beers->removeElement($beer);
  821.             // set the owning side to null (unless already changed)
  822.             if ($beer->getInstitution() === $this) {
  823.                 $beer->setInstitution(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection|Capacity[]
  832.      */
  833.     public function getCapacities(): Collection|array
  834.     {
  835.         return $this->capacities;
  836.     }
  838.     public function addCapacity(Capacity $capacity): self
  839.     {
  840.         if (!$this->capacities->contains($capacity)) {
  841.             $this->capacities[] = $capacity;
  842.             $capacity->setInstitution($this);
  843.         }
  845.         return $this;
  846.     }
  848.     public function removeCapacity(Capacity $capacity): self
  849.     {
  850.         if ($this->capacities->contains($capacity)) {
  851.             $this->capacities->removeElement($capacity);
  852.             // set the owning side to null (unless already changed)
  853.             if ($capacity->getInstitution() === $this) {
  854.                 $capacity->setInstitution(null);
  855.             }
  856.         }
  858.         return $this;
  859.     }
  861.     /**
  862.      * @return Collection|Creation[]
  863.      */
  864.     public function getCreations(): Collection|array
  865.     {
  866.         return $this->creations;
  867.     }
  869.     public function addCreation(Creation $creation): self
  870.     {
  871.         if (!$this->creations->contains($creation)) {
  872.             $this->creations[] = $creation;
  873.             $creation->setInstitution($this);
  874.         }
  876.         return $this;
  877.     }
  879.     public function removeCreation(Creation $creation): self
  880.     {
  881.         if ($this->creations->contains($creation)) {
  882.             $this->creations->removeElement($creation);
  883.             // set the owning side to null (unless already changed)
  884.             if ($creation->getInstitution() === $this) {
  885.                 $creation->setInstitution(null);
  886.             }
  887.         }
  889.         return $this;
  890.     }
  892.     /**
  893.      * @return Collection|CreationCategory[]
  894.      */
  895.     public function getCreationCategories(): Collection|array
  896.     {
  897.         return $this->creationCategories;
  898.     }
  900.     public function addCreationCategory(CreationCategory $creationCategory): self
  901.     {
  902.         if (!$this->creationCategories->contains($creationCategory)) {
  903.             $this->creationCategories[] = $creationCategory;
  904.             $creationCategory->setInstitution($this);
  905.         }
  907.         return $this;
  908.     }
  910.     public function removeCreationCategory(CreationCategory $creationCategory): self
  911.     {
  912.         if ($this->creationCategories->contains($creationCategory)) {
  913.             $this->creationCategories->removeElement($creationCategory);
  914.             // set the owning side to null (unless already changed)
  915.             if ($creationCategory->getInstitution() === $this) {
  916.                 $creationCategory->setInstitution(null);
  917.             }
  918.         }
  920.         return $this;
  921.     }
  923.     public function getIsDefault(): ?bool
  924.     {
  925.         return $this->isDefault;
  926.     }
  928.     /**
  929.      * @return Collection|WinePairing[]
  930.      */
  931.     public function getWinePairings(): array|Collection
  932.     {
  933.         return $this->winePairings;
  934.     }
  936.     public function addWinePairing(WinePairing $winePairing): self
  937.     {
  938.         if (!$this->winePairings->contains($winePairing)) {
  939.             $this->winePairings[] = $winePairing;
  940.             $winePairing->setInstitution($this);
  941.         }
  943.         return $this;
  944.     }
  946.     public function removeWinePairing(WinePairing $winePairing): self
  947.     {
  948.         if ($this->winePairings->contains($winePairing)) {
  949.             $this->winePairings->removeElement($winePairing);
  950.             // set the owning side to null (unless already changed)
  951.             if ($winePairing->getInstitution() === $this) {
  952.                 $winePairing->setInstitution(null);
  953.             }
  954.         }
  956.         return $this;
  957.     }
  959.     /**
  960.      * @return Collection|BeerPairing[]
  961.      */
  962.     public function getBeerPairings(): array|Collection
  963.     {
  964.         return $this->beerPairings;
  965.     }
  967.     public function addBeerPairing(BeerPairing $beerPairing): self
  968.     {
  969.         if (!$this->beerPairings->contains($beerPairing)) {
  970.             $this->beerPairings[] = $beerPairing;
  971.             $beerPairing->setInstitution($this);
  972.         }
  974.         return $this;
  975.     }
  977.     public function removeBeerPairing(BeerPairing $beerPairing): self
  978.     {
  979.         if ($this->beerPairings->contains($beerPairing)) {
  980.             $this->beerPairings->removeElement($beerPairing);
  981.             // set the owning side to null (unless already changed)
  982.             if ($beerPairing->getInstitution() === $this) {
  983.                 $beerPairing->setInstitution(null);
  984.             }
  985.         }
  987.         return $this;
  988.     }
  990.     /**
  991.      * @return Collection|PdfmenuDocument[]
  992.      */
  993.     public function getPdfmenuDocuments(): array|Collection
  994.     {
  995.         return $this->pdfmenuDocuments;
  996.     }
  998.     public function addPdfmenuDocument(PdfmenuDocument $pdfmenuDocument): self
  999.     {
  1000.         if (!$this->pdfmenuDocuments->contains($pdfmenuDocument)) {
  1001.             $this->pdfmenuDocuments[] = $pdfmenuDocument;
  1002.             $pdfmenuDocument->setInstitution($this);
  1003.         }
  1005.         return $this;
  1006.     }
  1008.     public function removePdfmenuDocument(PdfmenuDocument $pdfmenuDocument): self
  1009.     {
  1010.         if ($this->pdfmenuDocuments->contains($pdfmenuDocument)) {
  1011.             $this->pdfmenuDocuments->removeElement($pdfmenuDocument);
  1012.             // set the owning side to null (unless already changed)
  1013.             if ($pdfmenuDocument->getInstitution() === $this) {
  1014.                 $pdfmenuDocument->setInstitution(null);
  1015.             }
  1016.         }
  1018.         return $this;
  1019.     }
  1021.     public function getPdfmenuPersonalization(): ?PdfmenuPersonalization
  1022.     {
  1023.         return $this->pdfmenuPersonalization;
  1024.     }
  1026.     public function setPdfmenuPersonalization(?PdfmenuPersonalization $pdfmenuPersonalization): self
  1027.     {
  1028.         $this->pdfmenuPersonalization = $pdfmenuPersonalization;
  1030.         // set (or unset) the owning side of the relation if necessary
  1031.         $newInstitution = null === $pdfmenuPersonalization ? null : $this;
  1032.         if ($pdfmenuPersonalization->getInstitution() !== $newInstitution) {
  1033.             $pdfmenuPersonalization->setInstitution($newInstitution);
  1034.         }
  1036.         return $this;
  1037.     }
  1039.     public function getInstitutionAppPersonalization(): ?InstitutionAppPersonalization
  1040.     {
  1041.         return $this->institutionAppPersonalization;
  1042.     }
  1044.     public function setInstitutionAppPersonalization(?InstitutionAppPersonalization $institutionAppPersonalization): self
  1045.     {
  1046.         $this->institutionAppPersonalization = $institutionAppPersonalization;
  1048.         // set (or unset) the owning side of the relation if necessary
  1049.         $newInstitution = null === $institutionAppPersonalization ? null : $this;
  1050.         if ($institutionAppPersonalization->getInstitution() !== $newInstitution) {
  1051.             $institutionAppPersonalization->setInstitution($newInstitution);
  1052.         }
  1054.         return $this;
  1055.     }
  1057.     public function getDescription(): ?string
  1058.     {
  1059.         return $this->description;
  1060.     }
  1062.     public function setDescription(?string $description): self
  1063.     {
  1064.         $this->description = $description;
  1066.         return $this;
  1067.     }
  1069.     /**
  1070.      * @return Collection|OpeningHour[]
  1071.      */
  1072.     public function getOpeningHours(): array|Collection
  1073.     {
  1074.         return $this->openingHours;
  1075.     }
  1077.     public function addOpeningHour(OpeningHour $openingHour): self
  1078.     {
  1079.         if (!$this->openingHours->contains($openingHour)) {
  1080.             $this->openingHours[] = $openingHour;
  1081.             $openingHour->setInstitution($this);
  1082.         }
  1084.         return $this;
  1085.     }
  1087.     public function removeOpeningHour(OpeningHour $openingHour): self
  1088.     {
  1089.         if ($this->openingHours->removeElement($openingHour)) {
  1090.             // set the owning side to null (unless already changed)
  1091.             if ($openingHour->getInstitution() === $this) {
  1092.                 $openingHour->setInstitution(null);
  1093.             }
  1094.         }
  1096.         return $this;
  1097.     }
  1099.     /**
  1100.      * @return Collection|Grape[]
  1101.      */
  1102.     public function getGrapes(): Collection|array
  1103.     {
  1104.         return $this->grapes;
  1105.     }
  1107.     public function addGrape(Grape $grape): self
  1108.     {
  1109.         if (!$this->grapes->contains($grape)) {
  1110.             $this->grapes[] = $grape;
  1111.             $grape->setInstitution($this);
  1112.         }
  1114.         return $this;
  1115.     }
  1117.     public function removeGrape(Grape $grape): self
  1118.     {
  1119.         if ($this->grapes->contains($grape)) {
  1120.             $this->grapes->removeElement($grape);
  1121.             // set the owning side to null (unless already changed)
  1122.             if ($grape->getInstitution() === $this) {
  1123.                 $grape->setInstitution(null);
  1124.             }
  1125.         }
  1127.         return $this;
  1128.     }
  1130.     public function getIsPdfMenuActive(): ?bool
  1131.     {
  1132.         return $this->isPdfMenuActive;
  1133.     }
  1135.     public function setIsPdfMenuActive(?bool $isPdfMenuActive): self
  1136.     {
  1137.         $this->isPdfMenuActive = $isPdfMenuActive;
  1139.         return $this;
  1140.     }
  1142.     /**
  1143.      * @return Collection|InstitutionLocaleFront[]
  1144.      */
  1145.     public function getInstitutionLocaleFronts(): Collection|array
  1146.     {
  1147.         return $this->institutionLocaleFronts;
  1148.     }
  1150.     public function addInstitutionLocaleFront(InstitutionLocaleFront $institutionLocaleFront): self
  1151.     {
  1152.         if (!$this->institutionLocaleFronts->contains($institutionLocaleFront)) {
  1153.             $this->institutionLocaleFronts[] = $institutionLocaleFront;
  1154.             $institutionLocaleFront->setInstitution($this);
  1155.         }
  1157.         return $this;
  1158.     }
  1160.     public function removeInstitutionLocaleFront(InstitutionLocaleFront $institutionLocaleFront): self
  1161.     {
  1162.         if ($this->institutionLocaleFronts->removeElement($institutionLocaleFront)) {
  1163.             // set the owning side to null (unless already changed)
  1164.             if ($institutionLocaleFront->getInstitution() === $this) {
  1165.                 $institutionLocaleFront->setInstitution(null);
  1166.             }
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     /**
  1173.      * @return ArrayCollection
  1174.      */
  1175.     public function getActiveDishes(): ArrayCollection
  1176.     {
  1177.         $collections = new ArrayCollection();
  1179.         foreach ($this->getDishes() as $dish) {
  1180.             if ($dish->isActive()) {
  1181.                 if (!$collections->contains($dish)) {
  1182.                     $collections->add($dish);
  1183.                 }
  1184.             }
  1185.         }
  1187.         return $collections;
  1188.     }
  1190.     /**
  1191.      * @return ArrayCollection
  1192.      */
  1193.     public function getActiveWines(): ArrayCollection
  1194.     {
  1195.         $collections = new ArrayCollection();
  1197.         foreach ($this->getWines() as $wine) {
  1198.             if ($wine->isActive()) {
  1199.                 if (!$collections->contains($wine)) {
  1200.                     $collections->add($wine);
  1201.                 }
  1202.             }
  1203.         }
  1205.         return $collections;
  1206.     }
  1208.     /**
  1209.      * @return ArrayCollection
  1210.      */
  1211.     public function getActiveBeers(): ArrayCollection
  1212.     {
  1213.         $collections = new ArrayCollection();
  1215.         foreach ($this->getBeers() as $beer) {
  1216.             if ($beer->isActive()) {
  1217.                 if (!$collections->contains($beer)) {
  1218.                     $collections->add($beer);
  1219.                 }
  1220.             }
  1221.         }
  1223.         return $collections;
  1224.     }
  1226.     /**
  1227.      * @return ArrayCollection
  1228.      */
  1229.     public function getActiveDrinks(): ArrayCollection
  1230.     {
  1231.         $collections = new ArrayCollection();
  1233.         foreach ($this->getDrinks() as $drink) {
  1234.             if ($drink->isActive()) {
  1235.                 if (!$collections->contains($drink)) {
  1236.                     $collections->add($drink);
  1237.                 }
  1238.             }
  1239.         }
  1241.         return $collections;
  1242.     }
  1244.     /**
  1245.      * @return Collection|InstitutionReview[]
  1246.      */
  1247.     public function getInstitutionReviews(): Collection|array
  1248.     {
  1249.         return $this->institutionReviews;
  1250.     }
  1252.     public function addInstitutionReview(InstitutionReview $institutionReview): self
  1253.     {
  1254.         if (!$this->institutionReviews->contains($institutionReview)) {
  1255.             $this->institutionReviews[] = $institutionReview;
  1256.             $institutionReview->setInstitution($this);
  1257.         }
  1259.         return $this;
  1260.     }
  1262.     public function removeInstitutionReview(InstitutionReview $institutionReview): self
  1263.     {
  1264.         if ($this->institutionReviews->removeElement($institutionReview)) {
  1265.             // set the owning side to null (unless already changed)
  1266.             if ($institutionReview->getInstitution() === $this) {
  1267.                 $institutionReview->setInstitution(null);
  1268.             }
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     public function getInstitutionReviewSummary(): ?InstitutionReviewSummary
  1275.     {
  1276.         return $this->institutionReviewSummary;
  1277.     }
  1279.     public function setInstitutionReviewSummary(?InstitutionReviewSummary $institutionReviewSummary): self
  1280.     {
  1281.         $this->institutionReviewSummary = $institutionReviewSummary;
  1283.         // set (or unset) the owning side of the relation if necessary
  1284.         $newInstitution = null === $institutionReviewSummary ? null : $this;
  1285.         if ($institutionReviewSummary->getInstitution() !== $newInstitution) {
  1286.             $institutionReviewSummary->setInstitution($newInstitution);
  1287.         }
  1289.         return $this;
  1290.     }
  1292.     /**
  1293.      * @return Collection|Contest[]
  1294.      */
  1295.     public function getContests(): Collection|array
  1296.     {
  1297.         return $this->contests;
  1298.     }
  1300.     public function addContest(Contest $contest): self
  1301.     {
  1302.         if (!$this->contests->contains($contest)) {
  1303.             $this->contests[] = $contest;
  1304.             $contest->setInstitution($this);
  1305.         }
  1307.         return $this;
  1308.     }
  1310.     public function removeContest(Contest $contest): self
  1311.     {
  1312.         if ($this->contests->removeElement($contest)) {
  1313.             // set the owning side to null (unless already changed)
  1314.             if ($contest->getInstitution() === $this) {
  1315.                 $contest->setInstitution(null);
  1316.             }
  1317.         }
  1319.         return $this;
  1320.     }
  1322.     /**
  1323.      * @return Collection|Analysis[]
  1324.      */
  1325.     public function getAnalyses(): array|Collection
  1326.     {
  1327.         return $this->analyses;
  1328.     }
  1330.     public function addAnalysis(Analysis $analysis): self
  1331.     {
  1332.         if (!$this->analyses->contains($analysis)) {
  1333.             $this->analyses[] = $analysis;
  1334.             $analysis->setInstitution($this);
  1335.         }
  1337.         return $this;
  1338.     }
  1340.     public function removeAnalysis(Analysis $analysis): self
  1341.     {
  1342.         if ($this->analyses->removeElement($analysis)) {
  1343.             // set the owning side to null (unless already changed)
  1344.             if ($analysis->getInstitution() === $this) {
  1345.                 $analysis->setInstitution(null);
  1346.             }
  1347.         }
  1349.         return $this;
  1350.     }
  1352.     /**
  1353.      * @return Collection|Order[]
  1354.      */
  1355.     public function getOrders(): Collection|array
  1356.     {
  1357.         return $this->orders;
  1358.     }
  1360.     public function addOrder(Order $order): self
  1361.     {
  1362.         if (!$this->orders->contains($order)) {
  1363.             $this->orders[] = $order;
  1364.             $order->setInstitution($this);
  1365.         }
  1367.         return $this;
  1368.     }
  1370.     public function removeOrder(Order $order): self
  1371.     {
  1372.         if ($this->orders->removeElement($order)) {
  1373.             // set the owning side to null (unless already changed)
  1374.             if ($order->getInstitution() === $this) {
  1375.                 $order->setInstitution(null);
  1376.             }
  1377.         }
  1379.         return $this;
  1380.     }
  1382.     /**
  1383.      * @return Collection|ProductCategoryPosition[]
  1384.      */
  1385.     public function getProductCategoryPositions(): array|Collection
  1386.     {
  1387.         return $this->productCategoryPositions;
  1388.     }
  1390.     public function addProductCategoryPosition(ProductCategoryPosition $productCategoryPosition): self
  1391.     {
  1392.         if (!$this->productCategoryPositions->contains($productCategoryPosition)) {
  1393.             $this->productCategoryPositions[] = $productCategoryPosition;
  1394.             $productCategoryPosition->setInstitution($this);
  1395.         }
  1397.         return $this;
  1398.     }
  1400.     public function removeProductCategoryPosition(ProductCategoryPosition $productCategoryPosition): self
  1401.     {
  1402.         if ($this->productCategoryPositions->removeElement($productCategoryPosition)) {
  1403.             // set the owning side to null (unless already changed)
  1404.             if ($productCategoryPosition->getInstitution() === $this) {
  1405.                 $productCategoryPosition->setInstitution(null);
  1406.             }
  1407.         }
  1409.         return $this;
  1410.     }
  1412.     /**
  1413.      * @return Collection|Document[]
  1414.      */
  1415.     public function getGallery(): Collection|array
  1416.     {
  1417.         return $this->gallery;
  1418.     }
  1420.     public function addImageToGallery(Document $document): self
  1421.     {
  1422.         if (!$this->gallery->contains($document)) {
  1423.             $this->gallery[] = $document;
  1424.         }
  1426.         return $this;
  1427.     }
  1429.     public function removeImageFromGallery(Document $document): self
  1430.     {
  1431.         $this->gallery->removeElement($document);
  1433.         return $this;
  1434.     }
  1436.     public function resetGallery(): self
  1437.     {
  1438.         $this->gallery->clear();
  1440.         return $this;
  1441.     }
  1443.     public function getQrCodeLastDownloadAt(): ?DateTimeInterface
  1444.     {
  1445.         return $this->qrCodeLastDownloadAt;
  1446.     }
  1448.     public function setQrCodeLastDownloadAt(?DateTimeInterface $qrCodeLastDownloadAt): self
  1449.     {
  1450.         $this->qrCodeLastDownloadAt = $qrCodeLastDownloadAt;
  1452.         return $this;
  1453.     }
  1455.     public function addGallery(Document $gallery): self
  1456.     {
  1457.         if (!$this->gallery->contains($gallery)) {
  1458.             $this->gallery[] = $gallery;
  1459.         }
  1461.         return $this;
  1462.     }
  1464.     public function removeGallery(Document $gallery): self
  1465.     {
  1466.         $this->gallery->removeElement($gallery);
  1468.         return $this;
  1469.     }
  1471.     public function getInstitutionCurrency(): ?Currency
  1472.     {
  1473.         return $this->institutionCurrency;
  1474.     }
  1476.     public function setInstitutionCurrency(?Currency $currency): self
  1477.     {
  1478.         $this->institutionCurrency = $currency;
  1479.         return $this;
  1480.     }
  1481. }