src/Entity/Establishments.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EstablishmentsRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=EstablishmentsRepository::class)
  12.  */
  13. class Establishments
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", nullable=true)
  24.      */
  25.     private $idPunch = null;
  27.     /**
  28.      * @ORM\Column(type="string", length=255)
  29.      */
  30.     private $name;
  32.     /**
  33.      * @ORM\Column(type="string", length=255, nullable=true)
  34.      */
  35.     private $symbol = null;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $street = null;
  42.     /**
  43.      * @ORM\Column(type="string", length=255, nullable=true)
  44.      */
  45.     private $zip = null;
  47.     /**
  48.      * @ORM\Column(type="string", length=255, nullable=true)
  49.      */
  50.     private $city = null;
  52.     /**
  53.      * @ORM\Column(type="float")
  54.      */
  55.     private $tax = 0.0;
  57.     /**
  58.      * @ORM\Column(type="datetime")
  59.      */
  60.     private $createdAt;
  62.     /**
  63.      * @ORM\Column(type="string", length=255, nullable=true)
  64.      */
  65.     private $numberPhone = null;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      */
  70.     private $emailInfo = null;
  72.     /**
  73.      * @ORM\Column(type="string", length=255, nullable=true)
  74.      */
  75.     private $emailInvoice = null;
  77.     /**
  78.      * @ORM\Column(type="boolean")
  79.      */
  80.     private $deleted = false;
  82.     /**
  83.      * @ORM\Column(type="boolean")
  84.      */
  85.     private $validated = false;
  87.     /**
  88.      * @ORM\Column(type="boolean")
  89.      */
  90.     private $enableAppMobile = true;
  92.     /**
  93.      * @ORM\OneToMany(targetEntity=TypeEstablishment::class, mappedBy="establishment")
  94.      */
  95.     private $typeEstablishments;
  97.     /**
  98.      * @ORM\ManyToOne(targetEntity=EstablishmentStatus::class, inversedBy="establishments")
  99.      */
  100.     private $status;
  102.     /**
  103.      * @ORM\OneToMany(targetEntity=NumberOfCardCustomer::class, mappedBy="establishment")
  104.      */
  105.     private $numberOfCardCustomers;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=ReferenceUserEstablishment::class, mappedBy="customer")
  109.      */
  110.     private $referenceUserEstablishments;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=ReferenceUserEstablishment::class, mappedBy="establishment")
  114.      */
  115.     private $leadReferenceUserEstablishments;
  117.     /**
  118.      * @ORM\OneToMany(targetEntity=UserEstablishment::class, mappedBy="establishment")
  119.      */
  120.     private $userEstablishments;
  122.     /**
  123.      * @ORM\OneToMany(targetEntity=Articles::class, mappedBy="supplier")
  124.      */
  125.     private $articles;
  127.     /**
  128.      * @ORM\OneToMany(targetEntity=ShoppingCart::class, mappedBy="establishment")
  129.      */
  130.     private $shoppingCarts;
  132.     /**
  133.      * @ORM\OneToMany(targetEntity=Orders::class, mappedBy="establishment")
  134.      */
  135.     private $orders;
  137.     /**
  138.      * @ORM\ManyToOne(targetEntity=Users::class, inversedBy="establishments")
  139.      * @ORM\JoinColumn(nullable=true)
  140.      */
  141.     private $responsable;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=RequestModification::class, mappedBy="company")
  145.      */
  146.     private $requestModifications;
  148.     /**
  149.      * @ORM\ManyToOne(targetEntity=EstablishmentsCategories::class, inversedBy="establishments")
  150.      */
  151.     private $category;
  153.     /**
  154.      * @ORM\Column(type="float", nullable=true)
  155.      */
  156.     private $points;
  158.     /**
  159.      * @ORM\Column(type="string", length=255, nullable=true)
  160.      */
  161.     private $closingDays;
  163.     /**
  164.      * @ORM\Column(type="string", length=255, nullable=true)
  165.      */
  166.     private $deliveryDays;
  168.     /**
  169.      * @ORM\Column(type="string", length=255, nullable=true)
  170.      */
  171.     private $comment;
  173.     /**
  174.      * @ORM\OneToMany(targetEntity=EstablishmentDateVerified::class, mappedBy="establishment")
  175.      */
  176.     private $establishmentDateVerifieds;
  178.     /**
  179.      * Integer from 1 (Monday) to 7 (Sunday)
  180.      * @ORM\Column(type="integer", nullable=true)
  181.      */
  182.     private $deliveryDay = null;
  184.     /**
  185.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="Establishment")
  186.      */
  187.     private $favorites;
  189.     /**
  190.      * @ORM\OneToMany(targetEntity=RestrictionArticle::class, mappedBy="client")
  191.      */
  192.     private $restrictionArticles;
  194.     /**
  195.      * @ORM\Column(type="string", length=255, nullable=true)
  196.      */
  197.     private $route = null;
  199.     /**
  200.      * @ORM\Column(type="string", length=255, nullable=true)
  201.      */
  202.     private $routeName = null;
  204.     /**
  205.      * @ORM\ManyToOne(targetEntity=TarifCategory::class, inversedBy="establishments")
  206.      */
  207.     private $tarifCategory;
  209.     /**
  210.      * @ORM\ManyToOne(targetEntity=Establishments::class, inversedBy="establishmentsMaster")
  211.      */
  212.     private $establishmentInvoice;
  214.     /**
  215.      * @ORM\OneToMany(targetEntity=Establishments::class, mappedBy="establishmentInvoice")
  216.      */
  217.     private $establishmentsMaster;
  219.     /**
  220.      * @ORM\Column(type="string", length=255, nullable=true)
  221.      */
  222.     private $deliveryMoment = null;
  224.     /**
  225.      * @ORM\Column(type="string", length=255, nullable=true)
  226.      */
  227.     private $orderMoment = null;
  229.     /**
  230.      * @ORM\Column(type="string", length=255, nullable=true)
  231.      */
  232.     private $numberOfTax = null;
  234.     /**
  235.      * @ORM\Column(type="string", length=255, nullable=true)
  236.      */
  237.     private $responsableIdPunch = null;
  239.     /**
  240.      * @ORM\Column(type="datetime", nullable=true)
  241.      */
  242.     private $updatedAt;
  244.     /**
  245.      * @ORM\OneToMany(targetEntity=Invoice::class, mappedBy="establishment")
  246.      */
  247.     private $invoices;
  249.     /**
  250.      * @ORM\OneToMany(targetEntity=ArticleOrderOutOfStock::class, mappedBy="establishment")
  251.      */
  252.     private $articleOrderOutOfStocks;
  254.     /**
  255.      * @ORM\OneToMany(targetEntity=EstablishmentPromo::class, mappedBy="establishment")
  256.      */
  257.     private $establishmentPromos;
  259.     /**
  260.      * @ORM\OneToMany(targetEntity=BackOrder::class, mappedBy="establishment")
  261.      */
  262.     private $backOrders;
  264.     /**
  265.      * @ORM\OneToMany(targetEntity=InvoiceDownloads::class, mappedBy="establishment")
  266.      */
  267.     private $invoiceDownloads;
  269.     /**
  270.      * @ORM\OneToMany(targetEntity=Roles::class, mappedBy="establishment")
  271.      */
  272.     private $roles;
  274.     /**
  275.      * @ORM\OneToMany(targetEntity=Users::class, mappedBy="connectedAt")
  276.      */
  277.     private $usersConnected;
  279.     public function __construct()
  280.     {
  281.         $this->createdAt = new \DateTime();
  282.         $this->updatedAt = new \DateTime();
  283.         $this->typeEstablishments = new ArrayCollection();
  284.         $this->numberOfCardCustomers = new ArrayCollection();
  285.         $this->referenceUserEstablishments = new ArrayCollection();
  286.         $this->leadReferenceUserEstablishments = new ArrayCollection();
  287.         $this->userEstablishments = new ArrayCollection();
  288.         $this->articles = new ArrayCollection();
  289.         $this->shoppingCarts = new ArrayCollection();
  290.         $this->orders = new ArrayCollection();
  291.         $this->requestModifications = new ArrayCollection();
  292.         $this->establishmentDateVerifieds = new ArrayCollection();
  293.         $this->favorites = new ArrayCollection();
  294.         $this->restrictionArticles = new ArrayCollection();
  295.         $this->establishmentsMaster = new ArrayCollection();
  296.         $this->invoices = new ArrayCollection();
  297.         $this->articleOrderOutOfStocks = new ArrayCollection();
  298.         $this->establishmentPromos = new ArrayCollection();
  299.         $this->backOrders = new ArrayCollection();
  300.         $this->invoiceDownloads = new ArrayCollection();
  301.         $this->roles = new ArrayCollection();
  302.         $this->usersConnected = new ArrayCollection();
  303.     }
  305.     public function getId(): ?int
  306.     {
  307.         return $this->id;
  308.     }
  310.     public function getIdPunch(): ?string
  311.     {
  312.         return $this->idPunch;
  313.     }
  315.     public function setIdPunch(?string $idPunch): self
  316.     {
  317.         $this->idPunch = $idPunch;
  319.         return $this;
  320.     }
  322.     public function getName(): ?string
  323.     {
  324.         return $this->name;
  325.     }
  327.     public function setName(string $name): self
  328.     {
  329.         $this->name = $name;
  331.         return $this;
  332.     }
  334.     public function getSymbol(): ?string
  335.     {
  336.         return $this->symbol;
  337.     }
  339.     public function setSymbol(?string $symbol): self
  340.     {
  341.         $this->symbol = $symbol;
  343.         return $this;
  344.     }
  346.     public function getStreet(): ?string
  347.     {
  348.         return $this->street;
  349.     }
  351.     public function setStreet(?string $street): self
  352.     {
  353.         $this->street = $street;
  355.         return $this;
  356.     }
  358.     public function getZip(): ?string
  359.     {
  360.         return $this->zip;
  361.     }
  363.     public function setZip(?string $zip): self
  364.     {
  365.         $this->zip = $zip;
  367.         return $this;
  368.     }
  370.     public function getCity(): ?string
  371.     {
  372.         return $this->city;
  373.     }
  375.     public function setCity(?string $city): self
  376.     {
  377.         $this->city = $city;
  379.         return $this;
  380.     }
  382.     public function getTax(): ?float
  383.     {
  384.         return $this->tax;
  385.     }
  387.     public function setTax(float $tax): self
  388.     {
  389.         $this->tax = $tax;
  391.         return $this;
  392.     }
  394.     public function getCreatedAt(): ?\DateTimeInterface
  395.     {
  396.         return $this->createdAt;
  397.     }
  399.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  400.     {
  401.         $this->createdAt = $createdAt;
  403.         return $this;
  404.     }
  406.     public function getNumberPhone(): ?string
  407.     {
  408.         return $this->numberPhone;
  409.     }
  411.     public function setNumberPhone(?string $numberPhone): self
  412.     {
  413.         $this->numberPhone = $numberPhone;
  415.         return $this;
  416.     }
  418.     public function getEmailInfo(): ?string
  419.     {
  420.         return $this->emailInfo;
  421.     }
  423.     public function setEmailInfo(?string $emailInfo): self
  424.     {
  425.         $this->emailInfo = $emailInfo;
  427.         return $this;
  428.     }
  430.     public function getEmailInvoice(): ?string
  431.     {
  432.         return $this->emailInvoice;
  433.     }
  435.     public function setEmailInvoice(?string $emailInvoice): self
  436.     {
  437.         $this->emailInvoice = $emailInvoice;
  439.         return $this;
  440.     }
  442.     public function isDeleted(): ?bool
  443.     {
  444.         return $this->deleted;
  445.     }
  447.     public function setDeleted(bool $deleted): self
  448.     {
  449.         $this->deleted = $deleted;
  451.         return $this;
  452.     }
  454.     public function isValidated(): ?bool
  455.     {
  456.         return $this->validated;
  457.     }
  459.     public function setValidated(bool $validated): self
  460.     {
  461.         $this->validated = $validated;
  463.         return $this;
  464.     }
  466.     public function isEnableAppMobile(): ?bool
  467.     {
  468.         return $this->enableAppMobile;
  469.     }
  471.     public function setEnableAppMobile(bool $enableAppMobile): self
  472.     {
  473.         $this->enableAppMobile = $enableAppMobile;
  475.         return $this;
  476.     }
  478.     /**
  479.      * @return Collection<int, TypeEstablishment>
  480.      */
  481.     public function getTypeEstablishments(): Collection
  482.     {
  483.         return $this->typeEstablishments;
  484.     }
  486.     public function addTypeEstablishment(TypeEstablishment $typeEstablishment): self
  487.     {
  488.         if (!$this->typeEstablishments->contains($typeEstablishment)) {
  489.             $this->typeEstablishments[] = $typeEstablishment;
  490.             $typeEstablishment->setEstablishment($this);
  491.         }
  493.         return $this;
  494.     }
  496.     public function removeTypeEstablishment(TypeEstablishment $typeEstablishment): self
  497.     {
  498.         if ($this->typeEstablishments->removeElement($typeEstablishment)) {
  499.             // set the owning side to null (unless already changed)
  500.             if ($typeEstablishment->getEstablishment() === $this) {
  501.                 $typeEstablishment->setEstablishment(null);
  502.             }
  503.         }
  505.         return $this;
  506.     }
  508.     public function getStatus(): ?EstablishmentStatus
  509.     {
  510.         return $this->status;
  511.     }
  513.     public function setStatus(?EstablishmentStatus $status): self
  514.     {
  515.         $this->status = $status;
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection<int, NumberOfCardCustomer>
  522.      */
  523.     public function getNumberOfCardCustomers(): Collection
  524.     {
  525.         return $this->numberOfCardCustomers;
  526.     }
  528.     public function addNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  529.     {
  530.         if (!$this->numberOfCardCustomers->contains($numberOfCardCustomer)) {
  531.             $this->numberOfCardCustomers[] = $numberOfCardCustomer;
  532.             $numberOfCardCustomer->setEstablishment($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  539.     {
  540.         if ($this->numberOfCardCustomers->removeElement($numberOfCardCustomer)) {
  541.             // set the owning side to null (unless already changed)
  542.             if ($numberOfCardCustomer->getEstablishment() === $this) {
  543.                 $numberOfCardCustomer->setEstablishment(null);
  544.             }
  545.         }
  547.         return $this;
  548.     }
  550.     /**
  551.      * @return Collection<int, ReferenceUserEstablishment>
  552.      */
  553.     public function getReferenceUserEstablishments(): Collection
  554.     {
  555.         return $this->referenceUserEstablishments;
  556.     }
  558.     public function addReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  559.     {
  560.         if (!$this->referenceUserEstablishments->contains($referenceUserEstablishment)) {
  561.             $this->referenceUserEstablishments[] = $referenceUserEstablishment;
  562.             $referenceUserEstablishment->setCustomer($this);
  563.         }
  565.         return $this;
  566.     }
  568.     public function removeReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  569.     {
  570.         if ($this->referenceUserEstablishments->removeElement($referenceUserEstablishment)) {
  571.             // set the owning side to null (unless already changed)
  572.             if ($referenceUserEstablishment->getCustomer() === $this) {
  573.                 $referenceUserEstablishment->setCustomer(null);
  574.             }
  575.         }
  577.         return $this;
  578.     }
  580.     /**
  581.      * @return Collection<int, ReferenceUserEstablishment>
  582.      */
  583.     public function getLeadReferenceUserEstablishments(): Collection
  584.     {
  585.         return $this->leadReferenceUserEstablishments;
  586.     }
  588.     public function addLeadReferenceUserEstablishment(ReferenceUserEstablishment $leadReferenceUserEstablishment): self
  589.     {
  590.         if (!$this->leadReferenceUserEstablishments->contains($leadReferenceUserEstablishment)) {
  591.             $this->leadReferenceUserEstablishments[] = $leadReferenceUserEstablishment;
  592.             $leadReferenceUserEstablishment->setEstablishment($this);
  593.         }
  595.         return $this;
  596.     }
  598.     public function removeLeadReferenceUserEstablishment(ReferenceUserEstablishment $leadReferenceUserEstablishment): self
  599.     {
  600.         if ($this->leadReferenceUserEstablishments->removeElement($leadReferenceUserEstablishment)) {
  601.             // set the owning side to null (unless already changed)
  602.             if ($leadReferenceUserEstablishment->getEstablishment() === $this) {
  603.                 $leadReferenceUserEstablishment->setEstablishment(null);
  604.             }
  605.         }
  607.         return $this;
  608.     }
  610.     /**
  611.      * @return Collection<int, UserEstablishment>
  612.      */
  613.     public function getUserEstablishments(): Collection
  614.     {
  615.         return $this->userEstablishments;
  616.     }
  618.     public function addUserEstablishment(UserEstablishment $userEstablishment): self
  619.     {
  620.         if (!$this->userEstablishments->contains($userEstablishment)) {
  621.             $this->userEstablishments[] = $userEstablishment;
  622.             $userEstablishment->setEstablishment($this);
  623.         }
  625.         return $this;
  626.     }
  628.     public function removeUserEstablishment(UserEstablishment $userEstablishment): self
  629.     {
  630.         if ($this->userEstablishments->removeElement($userEstablishment)) {
  631.             // set the owning side to null (unless already changed)
  632.             if ($userEstablishment->getEstablishment() === $this) {
  633.                 $userEstablishment->setEstablishment(null);
  634.             }
  635.         }
  637.         return $this;
  638.     }
  640.     /**
  641.      * @return Collection<int, Articles>
  642.      */
  643.     public function getArticles(): Collection
  644.     {
  645.         return $this->articles;
  646.     }
  648.     public function addArticle(Articles $article): self
  649.     {
  650.         if (!$this->articles->contains($article)) {
  651.             $this->articles[] = $article;
  652.             $article->setSupplier($this);
  653.         }
  655.         return $this;
  656.     }
  658.     public function removeArticle(Articles $article): self
  659.     {
  660.         if ($this->articles->removeElement($article)) {
  661.             // set the owning side to null (unless already changed)
  662.             if ($article->getSupplier() === $this) {
  663.                 $article->setSupplier(null);
  664.             }
  665.         }
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection<int, ShoppingCart>
  672.      */
  673.     public function getShoppingCarts(): Collection
  674.     {
  675.         return $this->shoppingCarts;
  676.     }
  678.     public function addShoppingCart(ShoppingCart $shoppingCart): self
  679.     {
  680.         if (!$this->shoppingCarts->contains($shoppingCart)) {
  681.             $this->shoppingCarts[] = $shoppingCart;
  682.             $shoppingCart->setEstablishment($this);
  683.         }
  685.         return $this;
  686.     }
  688.     public function removeShoppingCart(ShoppingCart $shoppingCart): self
  689.     {
  690.         if ($this->shoppingCarts->removeElement($shoppingCart)) {
  691.             // set the owning side to null (unless already changed)
  692.             if ($shoppingCart->getEstablishment() === $this) {
  693.                 $shoppingCart->setEstablishment(null);
  694.             }
  695.         }
  697.         return $this;
  698.     }
  700.     /**
  701.      * @return Collection<int, Orders>
  702.      */
  703.     public function getOrders(): Collection
  704.     {
  705.         return $this->orders;
  706.     }
  708.     public function getStandardOrders(): ?Orders
  709.     {
  710.         foreach ($this->orders as $order){
  711.             if($order->getStandard()){
  712.                 return $order;
  713.             }
  714.         }
  715.         return null;
  716.     }
  718.     public function addOrder(Orders $order): self
  719.     {
  720.         if (!$this->orders->contains($order)) {
  721.             $this->orders[] = $order;
  722.             $order->setEstablishment($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeOrder(Orders $order): self
  729.     {
  730.         if ($this->orders->removeElement($order)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($order->getEstablishment() === $this) {
  733.                 $order->setEstablishment(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     public function getResponsable(): ?Users
  741.     {
  742.         return $this->responsable;
  743.     }
  745.     public function setResponsable(?Users $responsable): self
  746.     {
  747.         $this->responsable = $responsable;
  749.         return $this;
  750.     }
  752.     /**
  753.      * @return Collection<int, RequestModification>
  754.      */
  755.     public function getRequestModifications(): Collection
  756.     {
  757.         return $this->requestModifications;
  758.     }
  760.     public function addRequestModification(RequestModification $requestModification): self
  761.     {
  762.         if (!$this->requestModifications->contains($requestModification)) {
  763.             $this->requestModifications[] = $requestModification;
  764.             $requestModification->setCompany($this);
  765.         }
  767.         return $this;
  768.     }
  770.     public function removeRequestModification(RequestModification $requestModification): self
  771.     {
  772.         if ($this->requestModifications->removeElement($requestModification)) {
  773.             // set the owning side to null (unless already changed)
  774.             if ($requestModification->getCompany() === $this) {
  775.                 $requestModification->setCompany(null);
  776.             }
  777.         }
  779.         return $this;
  780.     }
  782.     public function getCategory(): ?EstablishmentsCategories
  783.     {
  784.         return $this->category;
  785.     }
  787.     public function setCategory(?EstablishmentsCategories $category): self
  788.     {
  789.         $this->category = $category;
  791.         return $this;
  792.     }
  794.     public function getPoints(): ?float
  795.     {
  796.         return $this->points;
  797.     }
  799.     public function setPoints(?float $points): self
  800.     {
  801.         $this->points = $points;
  802.         return $this;
  803.     }
  805.     public function getClosingDays(): ?string
  806.     {
  807.         return $this->closingDays;
  808.     }
  810.     public function setClosingDays(?string $closingDays): self
  811.     {
  812.         $this->closingDays = $closingDays;
  813.         return $this;
  814.     }
  816.     /**
  817.      * @return Collection<int, EstablishmentDateVerified>
  818.      */
  819.     public function getEstablishmentDateVerifieds(): Collection
  820.     {
  821.         return $this->establishmentDateVerifieds;
  822.     }
  824.     public function addEstablishmentDateVerified(EstablishmentDateVerified $establishmentDateVerified): self
  825.     {
  826.         if (!$this->establishmentDateVerifieds->contains($establishmentDateVerified)) {
  827.             $this->establishmentDateVerifieds[] = $establishmentDateVerified;
  828.             $establishmentDateVerified->setEstablishment($this);
  829.         }
  831.         return $this;
  832.     }
  834.     public function getDeliveryDays(): ?string
  835.     {
  836.         return $this->deliveryDays;
  837.     }
  839.     public function setDeliveryDays(?string $deliveryDays): self
  840.     {
  841.         $this->deliveryDays = $deliveryDays;
  842.         return $this;
  843.     }
  845.     public function removeEstablishmentDateVerified(EstablishmentDateVerified $establishmentDateVerified): self
  846.     {
  847.         if ($this->establishmentDateVerifieds->removeElement($establishmentDateVerified)) {
  848.             // set the owning side to null (unless already changed)
  849.             if ($establishmentDateVerified->getEstablishment() === $this) {
  850.                 $establishmentDateVerified->setEstablishment(null);
  851.             }
  852.         }
  854.         return $this;
  855.     }
  857.     public function getComment(): ?string
  858.     {
  859.         return $this->comment;
  860.     }
  862.     public function setComment(?string $comment): self
  863.     {
  864.         $this->comment = $comment;
  865.         return $this;
  866.     }
  868.     public function getDeliveryDay(): ?int
  869.     {
  870.         return $this->deliveryDay;
  871.     }
  873.     public function setDeliveryDay(?int $deliveryDay): self
  874.     {
  875.         $this->deliveryDay = $deliveryDay;
  877.         return $this;
  878.     }
  880.     /**
  881.      * @return Collection<int, Favorite>
  882.      */
  883.     public function getFavorites(): Collection
  884.     {
  885.         return $this->favorites;
  886.     }
  888.     public function addFavorite(Favorite $favorite): self
  889.     {
  890.         if (!$this->favorites->contains($favorite)) {
  891.             $this->favorites[] = $favorite;
  892.             $favorite->setEstablishment($this);
  893.         }
  895.         return $this;
  896.     }
  898.     public function removeFavorite(Favorite $favorite): self
  899.     {
  900.         if ($this->favorites->removeElement($favorite)) {
  901.             // set the owning side to null (unless already changed)
  902.             if ($favorite->getEstablishment() === $this) {
  903.                 $favorite->setEstablishment(null);
  904.             }
  905.         }
  907.         return $this;
  908.     }
  910.     /**
  911.      * @return Collection<int, RestrictionArticle>
  912.      */
  913.     public function getRestrictionArticles(): Collection
  914.     {
  915.         return $this->restrictionArticles;
  916.     }
  918.     public function addRestrictionArticle(RestrictionArticle $restrictionArticle): self
  919.     {
  920.         if (!$this->restrictionArticles->contains($restrictionArticle)) {
  921.             $this->restrictionArticles[] = $restrictionArticle;
  922.             $restrictionArticle->setClient($this);
  923.         }
  925.         return $this;
  926.     }
  928.     public function removeRestrictionArticle(RestrictionArticle $restrictionArticle): self
  929.     {
  930.         if ($this->restrictionArticles->removeElement($restrictionArticle)) {
  931.             // set the owning side to null (unless already changed)
  932.             if ($restrictionArticle->getClient() === $this) {
  933.                 $restrictionArticle->setClient(null);
  934.             }
  935.         }
  937.         return $this;
  938.     }
  940.     public function getRoute(): ?string
  941.     {
  942.         return $this->route;
  943.     }
  945.     public function setRoute(?string $route): self
  946.     {
  947.         $this->route = $route;
  949.         return $this;
  950.     }
  952.     public function getRouteName(): ?string
  953.     {
  954.         return $this->routeName;
  955.     }
  957.     public function setRouteName(?string $routeName): self
  958.     {
  959.         $this->routeName = $routeName;
  961.         return $this;
  962.     }
  964.     public function getTarifCategory(): ?TarifCategory
  965.     {
  966.         return $this->tarifCategory;
  967.     }
  969.     public function setTarifCategory(?TarifCategory $tarifCategory): self
  970.     {
  971.         $this->tarifCategory = $tarifCategory;
  973.         return $this;
  974.     }
  976.     public function getEstablishmentInvoice(): ?self
  977.     {
  978.         return $this->establishmentInvoice;
  979.     }
  981.     public function setEstablishmentInvoice(?self $establishmentInvoice): self
  982.     {
  983.         $this->establishmentInvoice = $establishmentInvoice;
  985.         return $this;
  986.     }
  988.     /**
  989.      * @return Collection<int, self>
  990.      */
  991.     public function getEstablishmentsMaster(): Collection
  992.     {
  993.         return $this->establishmentsMaster;
  994.     }
  996.     public function addEstablishmentsMaster(self $establishmentsMaster): self
  997.     {
  998.         if (!$this->establishmentsMaster->contains($establishmentsMaster)) {
  999.             $this->establishmentsMaster[] = $establishmentsMaster;
  1000.             $establishmentsMaster->setEstablishmentInvoice($this);
  1001.         }
  1003.         return $this;
  1004.     }
  1006.     public function removeEstablishmentsMaster(self $establishmentsMaster): self
  1007.     {
  1008.         if ($this->establishmentsMaster->removeElement($establishmentsMaster)) {
  1009.             // set the owning side to null (unless already changed)
  1010.             if ($establishmentsMaster->getEstablishmentInvoice() === $this) {
  1011.                 $establishmentsMaster->setEstablishmentInvoice(null);
  1012.             }
  1013.         }
  1015.         return $this;
  1016.     }
  1018.     public function getDeliveryMoment(): ?string
  1019.     {
  1020.         return $this->deliveryMoment;
  1021.     }
  1023.     public function setDeliveryMoment(?string $deliveryMoment): self
  1024.     {
  1025.         $this->deliveryMoment = $deliveryMoment;
  1027.         return $this;
  1028.     }
  1030.     public function getOrderMoment(): ?string
  1031.     {
  1032.         return $this->orderMoment;
  1033.     }
  1035.     public function setOrderMoment(?string $orderMoment): self
  1036.     {
  1037.         $this->orderMoment = $orderMoment;
  1039.         return $this;
  1040.     }
  1042.     public function getNumberOfTax(): ?string
  1043.     {
  1044.         return $this->numberOfTax;
  1045.     }
  1047.     public function setNumberOfTax(?string $numberOfTax): self
  1048.     {
  1049.         $this->numberOfTax = $numberOfTax;
  1051.         return $this;
  1052.     }
  1054.     public function getResponsableIdPunch(): ?string
  1055.     {
  1056.         return $this->responsableIdPunch;
  1057.     }
  1059.     public function setResponsableIdPunch(?string $responsableIdPunch): self
  1060.     {
  1061.         $this->responsableIdPunch = $responsableIdPunch;
  1063.         return $this;
  1064.     }
  1066.     public function getUpdatedAt(): ?\DateTimeInterface
  1067.     {
  1068.         return $this->updatedAt;
  1069.     }
  1071.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  1072.     {
  1073.         $this->updatedAt = $updatedAt;
  1075.         return $this;
  1076.     }
  1078.     /**
  1079.      * @return Collection<int, Invoice>
  1080.      */
  1081.     public function getInvoices(): Collection
  1082.     {
  1083.         return $this->invoices;
  1084.     }
  1086.     public function addInvoice(Invoice $invoice): self
  1087.     {
  1088.         if (!$this->invoices->contains($invoice)) {
  1089.             $this->invoices[] = $invoice;
  1090.             $invoice->setEstablishment($this);
  1091.         }
  1093.         return $this;
  1094.     }
  1096.     public function removeInvoice(Invoice $invoice): self
  1097.     {
  1098.         if ($this->invoices->removeElement($invoice)) {
  1099.             // set the owning side to null (unless already changed)
  1100.             if ($invoice->getEstablishment() === $this) {
  1101.                 $invoice->setEstablishment(null);
  1102.             }
  1103.         }
  1105.         return $this;
  1106.     }
  1108.     /**
  1109.      * @return Collection<int, ArticleOrderOutOfStock>
  1110.      */
  1111.     public function getArticleOrderOutOfStocks(): Collection
  1112.     {
  1113.         return $this->articleOrderOutOfStocks;
  1114.     }
  1116.     public function addArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1117.     {
  1118.         if (!$this->articleOrderOutOfStocks->contains($articleOrderOutOfStock)) {
  1119.             $this->articleOrderOutOfStocks[] = $articleOrderOutOfStock;
  1120.             $articleOrderOutOfStock->setEstablishment($this);
  1121.         }
  1123.         return $this;
  1124.     }
  1126.     public function removeArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1127.     {
  1128.         if ($this->articleOrderOutOfStocks->removeElement($articleOrderOutOfStock)) {
  1129.             // set the owning side to null (unless already changed)
  1130.             if ($articleOrderOutOfStock->getEstablishment() === $this) {
  1131.                 $articleOrderOutOfStock->setEstablishment(null);
  1132.             }
  1133.         }
  1135.         return $this;
  1136.     }
  1138.     /**
  1139.      * @return Collection<int, EstablishmentPromo>
  1140.      */
  1141.     public function getEstablishmentPromos(): Collection
  1142.     {
  1143.         return $this->establishmentPromos;
  1144.     }
  1146.     public function addEstablishmentPromo(EstablishmentPromo $establishmentPromo): self
  1147.     {
  1148.         if (!$this->establishmentPromos->contains($establishmentPromo)) {
  1149.             $this->establishmentPromos[] = $establishmentPromo;
  1150.             $establishmentPromo->setEstablishment($this);
  1151.         }
  1153.         return $this;
  1154.     }
  1156.     public function removeEstablishmentPromo(EstablishmentPromo $establishmentPromo): self
  1157.     {
  1158.         if ($this->establishmentPromos->removeElement($establishmentPromo)) {
  1159.             // set the owning side to null (unless already changed)
  1160.             if ($establishmentPromo->getEstablishment() === $this) {
  1161.                 $establishmentPromo->setEstablishment(null);
  1162.             }
  1163.         }
  1165.         return $this;
  1166.     }
  1168.     /**
  1169.      * @return Collection<int, BackOrder>
  1170.      */
  1171.     public function getBackOrders(): Collection
  1172.     {
  1173.         return $this->backOrders;
  1174.     }
  1176.     public function addBackOrder(BackOrder $backOrder): self
  1177.     {
  1178.         if (!$this->backOrders->contains($backOrder)) {
  1179.             $this->backOrders[] = $backOrder;
  1180.             $backOrder->setEstablishment($this);
  1181.         }
  1183.         return $this;
  1184.     }
  1186.     public function removeBackOrder(BackOrder $backOrder): self
  1187.     {
  1188.         if ($this->backOrders->removeElement($backOrder)) {
  1189.             // set the owning side to null (unless already changed)
  1190.             if ($backOrder->getEstablishment() === $this) {
  1191.                 $backOrder->setEstablishment(null);
  1192.             }
  1193.         }
  1195.         return $this;
  1196.     }
  1198.     /**
  1199.      * @return Collection<int, InvoiceDownloads>
  1200.      */
  1201.     public function getInvoiceDownloads(): Collection
  1202.     {
  1203.         return $this->invoiceDownloads;
  1204.     }
  1206.     public function addInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1207.     {
  1208.         if (!$this->invoiceDownloads->contains($invoiceDownload)) {
  1209.             $this->invoiceDownloads[] = $invoiceDownload;
  1210.             $invoiceDownload->setEstablishment($this);
  1211.         }
  1213.         return $this;
  1214.     }
  1216.     public function removeInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1217.     {
  1218.         if ($this->invoiceDownloads->removeElement($invoiceDownload)) {
  1219.             // set the owning side to null (unless already changed)
  1220.             if ($invoiceDownload->getEstablishment() === $this) {
  1221.                 $invoiceDownload->setEstablishment(null);
  1222.             }
  1223.         }
  1225.         return $this;
  1226.     }
  1228.     /**
  1229.      * @return Collection<int, Roles>
  1230.      */
  1231.     public function getRoles(): Collection
  1232.     {
  1233.         return $this->roles;
  1234.     }
  1236.     public function addRole(Roles $role): self
  1237.     {
  1238.         if (!$this->roles->contains($role)) {
  1239.             $this->roles[] = $role;
  1240.             $role->setEstablishment($this);
  1241.         }
  1243.         return $this;
  1244.     }
  1246.     public function removeRole(Roles $role): self
  1247.     {
  1248.         if ($this->roles->removeElement($role)) {
  1249.             // set the owning side to null (unless already changed)
  1250.             if ($role->getEstablishment() === $this) {
  1251.                 $role->setEstablishment(null);
  1252.             }
  1253.         }
  1255.         return $this;
  1256.     }
  1258.     /**
  1259.      * @return Collection<int, Users>
  1260.      */
  1261.     public function getUsersConnected(): Collection
  1262.     {
  1263.         return $this->usersConnected;
  1264.     }
  1266.     public function addUsersConnected(Users $usersConnected): self
  1267.     {
  1268.         if (!$this->usersConnected->contains($usersConnected)) {
  1269.             $this->usersConnected[] = $usersConnected;
  1270.             $usersConnected->setConnectedAt($this);
  1271.         }
  1273.         return $this;
  1274.     }
  1276.     public function removeUsersConnected(Users $usersConnected): self
  1277.     {
  1278.         if ($this->usersConnected->removeElement($usersConnected)) {
  1279.             // set the owning side to null (unless already changed)
  1280.             if ($usersConnected->getConnectedAt() === $this) {
  1281.                 $usersConnected->setConnectedAt(null);
  1282.             }
  1283.         }
  1285.         return $this;
  1286.     }
  1288. }