src/Entity/Users.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UsersRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  11. /**
  12.  * @ORM\Entity(repositoryClass=UsersRepository::class)
  13.  */
  14. class Users implements UserInterface, \Serializable
  15. {
  16.     /**
  17.      * @ORM\Id
  18.      * @ORM\GeneratedValue
  19.      * @ORM\Column(type="integer")
  20.      */
  21.     private $id;
  23.     /**
  24.      * @ORM\Column(type="integer", nullable=true)
  25.      */
  26.     private $idPunch = null;
  28.     /**
  29.      * @ORM\Column(type="string", length=255, nullable=true)
  30.      */
  31.     private $firstname = null;
  33.     /**
  34.      * @ORM\Column(type="string", length=255, nullable=true)
  35.      */
  36.     private $lastname = null;
  38.     /**
  39.      * @ORM\Column(type="string", length=255, nullable=true)
  40.      */
  41.     private $email = null;
  43.     /**
  44.      * @ORM\Column(type="datetime")
  45.      */
  46.     private $createdAt;
  48.     /**
  49.      * @ORM\Column(type="boolean")
  50.      */
  51.     private $deleted = false;
  53.     /**
  54.      * @ORM\Column(type="string", length=255, nullable=true)
  55.      */
  56.     private $token = null;
  58.     /**
  59.      * @ORM\Column(type="string", length=255)
  60.      */
  61.     private $password;
  63.     /**
  64.      * @ORM\Column(type="boolean")
  65.      */
  66.     private $validated = true;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=NumberOfCardCustomer::class, mappedBy="customer")
  70.      */
  71.     private $numberOfCardCustomers;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=TypeEstablishment::class, mappedBy="createdBy")
  75.      */
  76.     private $typeEstablishments;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=ReferenceUserEstablishment::class, mappedBy="user")
  80.      */
  81.     private $referenceUserEstablishments;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity=UserEstablishment::class, mappedBy="user")
  85.      */
  86.     private $userEstablishments;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity=ShoppingCart::class, mappedBy="createdBy")
  90.      */
  91.     private $shoppingCarts;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity=Orders::class, mappedBy="validatedBy")
  95.      */
  96.     private $ordersValidated;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=OrderArticle::class, mappedBy="createdBy")
  100.      */
  101.     private $createdOrderArticle;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=RequestModification::class, mappedBy="createdBy")
  105.      */
  106.     private $requestModifications;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=RequestModification::class, mappedBy="responsable")
  110.      */
  111.     private $requestModificationsResponsable;
  113.     /**
  114.      * @ORM\OneToMany(targetEntity=Establishments::class, mappedBy="responsable")
  115.      */
  116.     private $establishments;
  118.     /**
  119.      * @ORM\ManyToOne(targetEntity=Users::class, inversedBy="myCustomers")
  120.      */
  121.     private $myResponsable;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=Users::class, mappedBy="myResponsable")
  125.      */
  126.     private $myCustomers;
  128.     /**
  129.      * @ORM\Column(type="boolean")
  130.      */
  131.     private $notPresent = false;
  133.     /**
  134.      * @ORM\Column(type="string", length=255, nullable=true)
  135.      */
  136.     private $city = null;
  138.     /**
  139.      * @ORM\Column(type="string", length=255, nullable=true)
  140.      */
  141.     private $zip = null;
  143.     /**
  144.      * @ORM\Column(type="string", length=255, nullable=true)
  145.      */
  146.     private $numberPhone = null;
  148.     /**
  149.      * @ORM\OneToMany(targetEntity=Orders::class, mappedBy="user")
  150.      */
  151.     private $orders;
  153.     /**
  154.      * @ORM\Column(type="float", nullable=true)
  155.      */
  156.     private $points = null;
  158.     /**
  159.      * @ORM\OneToMany(targetEntity=ShoppingCart::class, mappedBy="user")
  160.      */
  161.     private $shoppingCartsUsers;
  163.     /**
  164.      * @ORM\OneToMany(targetEntity=ShoppingCart::class, mappedBy="updatedBy")
  165.      */
  166.     private $shppingCartsUpdatedBy;
  168.     /**
  169.      * @ORM\Column(type="string", length=255, nullable=true)
  170.      */
  171.     private $clientCard = null;
  173.     /**
  174.      * @ORM\Column(type="boolean")
  175.      */
  176.     private $cgvAccepted = false;
  178.     /**
  179.      * @ORM\OneToMany(targetEntity=Orders::class, mappedBy="lastPickupUpdateBy")
  180.      */
  181.     private $lastPickupUpdateOrder;
  183.     /**
  184.      * @ORM\Column(type="string", length=255, nullable=true)
  185.      */
  186.     private $genre = null;
  188.     /**
  189.      * @ORM\Column(type="string", length=255, nullable=true)
  190.      */
  191.     private $address = null;
  193.     /**
  194.      * @ORM\Column(type="string", length=255, nullable=true)
  195.      */
  196.     private $TvaNumber = null;
  198.     /**
  199.      * @ORM\Column(type="integer", nullable=true)
  200.      */
  201.     private $newPasswordCode = null;
  203.     /**
  204.      * @ORM\Column(type="datetime", nullable=true)
  205.      */
  206.     private $newPasswordCreatedAt = null;
  208.     /**
  209.      * @ORM\Column(type="boolean")
  210.      */
  211.     private $emailValidated = false;
  213.     /**
  214.      * @ORM\Column(type="string", length=255, nullable=true)
  215.      */
  216.     private $emailValidationToken = null;
  218.     /**
  219.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="User")
  220.      */
  221.     private $favorites;
  223.     /**
  224.      * @ORM\Column(type="string", length=255, nullable=true)
  225.      */
  226.     private $newPasswordToken = null;
  228.     /**
  229.      * @ORM\ManyToOne(targetEntity=UserStatusIntern::class, inversedBy="users")
  230.      */
  231.     private $statusIntern;
  233.     /**
  234.      * @ORM\OneToMany(targetEntity=Banner::class, mappedBy="createdBy")
  235.      */
  236.     private $banners;
  238.     /**
  239.      * @ORM\ManyToOne(targetEntity=TVA::class, inversedBy="users")
  240.      */
  241.     private $tva;
  243.     /**
  244.      * @ORM\Column(type="boolean")
  245.      */
  246.     private $firstConnexion = false;
  248.     /**
  249.      * @ORM\OneToMany(targetEntity=Invoice::class, mappedBy="user")
  250.      */
  251.     private $invoices;
  253.     /**
  254.      * @ORM\OneToMany(targetEntity=EmailInvoice::class, mappedBy="addedBy")
  255.      */
  256.     private $emailInvoices;
  258.     /**
  259.      * @ORM\OneToMany(targetEntity=ArticleOrderOutOfStock::class, mappedBy="user")
  260.      */
  261.     private $articleOrderOutOfStocks;
  263.     /**
  264.      * @ORM\OneToMany(targetEntity=BackOrder::class, mappedBy="createdBy")
  265.      */
  266.     private $backOrders;
  268.     /**
  269.      * @ORM\OneToMany(targetEntity=InvoiceDownloads::class, mappedBy="user")
  270.      */
  271.     private $invoiceDownloads;
  273.     /**
  274.      * @ORM\OneToMany(targetEntity=Articles::class, mappedBy="visibleBy")
  275.      */
  276.     private $articlesChangeVisibility;
  278.     /**
  279.      * @ORM\OneToMany(targetEntity=ChildTags::class, mappedBy="updatedBy")
  280.      */
  281.     private $childTagsUpdate;
  283.     /**
  284.      * @ORM\OneToMany(targetEntity=TagGroups::class, mappedBy="updatedBy")
  285.      */
  286.     private $tagGroupsUpdate;
  288.     /**
  289.      * @ORM\OneToMany(targetEntity=Feedback::class, mappedBy="user")
  290.      */
  291.     private $feedback;
  293.     /**
  294.      * @ORM\Column(type="datetime", nullable=true)
  295.      */
  296.     private $deletedAt = null;
  298.     /**
  299.      * @ORM\ManyToOne(targetEntity=Users::class)
  300.      */
  301.     private $deletedBy;
  303.     /**
  304.      * @ORM\Column(type="string", nullable=true)
  305.      */
  306.     private $zendeskId = null;
  308.     /**
  309.      * @ORM\ManyToOne(targetEntity=Establishments::class, inversedBy="usersConnected")
  310.      */
  311.     private $connectedAt;
  313.     /**
  314.      * @ORM\OneToMany(targetEntity=ListRestriction::class, mappedBy="createdBy")
  315.      */
  316.     private $listRestrictions;
  318.     /**
  319.      * @ORM\OneToMany(targetEntity=ListRestrictionEstablishment::class, mappedBy="createdBy")
  320.      */
  321.     private $getListRestrictionEstablishmentsCreatedBy;
  323.     public function __construct()
  324.     {
  325.         $this->createdAt = new \DateTime();
  326.         $this->numberOfCardCustomers = new ArrayCollection();
  327.         $this->typeEstablishments = new ArrayCollection();
  328.         $this->referenceUserEstablishments = new ArrayCollection();
  329.         $this->userEstablishments = new ArrayCollection();
  330.         $this->shoppingCarts = new ArrayCollection();
  331.         $this->ordersValidated = new ArrayCollection();
  332.         $this->createdOrderArticle = new ArrayCollection();
  333.         $this->requestModifications = new ArrayCollection();
  334.         $this->requestModificationsResponsable = new ArrayCollection();
  335.         $this->establishments = new ArrayCollection();
  336.         $this->myCustomers = new ArrayCollection();
  337.         $this->orders = new ArrayCollection();
  338.         $this->shoppingCartsUsers = new ArrayCollection();
  339.         $this->shppingCartsUpdatedBy = new ArrayCollection();
  340.         $this->lastPickupUpdateOrder = new ArrayCollection();
  341.         $this->favorites = new ArrayCollection();
  342.         $this->banners = new ArrayCollection();
  343.         $this->invoices = new ArrayCollection();
  344.         $this->emailInvoices = new ArrayCollection();
  345.         $this->articleOrderOutOfStocks = new ArrayCollection();
  346.         $this->backOrders = new ArrayCollection();
  347.         $this->invoiceDownloads = new ArrayCollection();
  348.         $this->articlesChangeVisibility = new ArrayCollection();
  349.         $this->childTagsUpdate = new ArrayCollection();
  350.         $this->tagGroupsUpdate = new ArrayCollection();
  351.         $this->feedback = new ArrayCollection();
  352.         $this->listRestrictions = new ArrayCollection();
  353.         $this->getListRestrictionEstablishmentsCreatedBy = new ArrayCollection();
  354.     }
  356.     public function getId(): ?int
  357.     {
  358.         return $this->id;
  359.     }
  361.     public function getPassword(): ?string
  362.     {
  363.         return $this->password;
  364.     }
  366.     public function setPassword(string $password): self
  367.     {
  368.         $this->password = $password;
  370.         return $this;
  371.     }
  373.     public function getIdPunch(): ?int
  374.     {
  375.         return $this->idPunch;
  376.     }
  378.     public function setIdPunch(?int $idPunch): self
  379.     {
  380.         $this->idPunch = $idPunch;
  382.         return $this;
  383.     }
  385.     public function getFirstname(): ?string
  386.     {
  387.         return $this->firstname;
  388.     }
  390.     public function setFirstname(?string $firstname): self
  391.     {
  392.         $this->firstname = $firstname;
  394.         return $this;
  395.     }
  397.     public function getLastname(): ?string
  398.     {
  399.         return $this->lastname;
  400.     }
  402.     public function setLastname(?string $lastname): self
  403.     {
  404.         $this->lastname = $lastname;
  406.         return $this;
  407.     }
  409.     public function getEmail(): ?string
  410.     {
  411.         return $this->email;
  412.     }
  414.     public function setEmail(?string $email): self
  415.     {
  416.         $this->email = $email;
  418.         return $this;
  419.     }
  421.     public function getCreatedAt(): ?\DateTimeInterface
  422.     {
  423.         return $this->createdAt;
  424.     }
  426.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  427.     {
  428.         $this->createdAt = $createdAt;
  430.         return $this;
  431.     }
  433.     public function isDeleted(): ?bool
  434.     {
  435.         return $this->deleted;
  436.     }
  438.     public function setDeleted(bool $deleted): self
  439.     {
  440.         $this->deleted = $deleted;
  442.         return $this;
  443.     }
  445.     public function getToken(): ?string
  446.     {
  447.         return $this->token;
  448.     }
  450.     public function setToken(?string $token): self
  451.     {
  452.         $this->token = $token;
  454.         return $this;
  455.     }
  457.     public function isValidated(): ?bool
  458.     {
  459.         return $this->validated;
  460.     }
  462.     public function setValidated(bool $validated): self
  463.     {
  464.         $this->validated = $validated;
  466.         return $this;
  467.     }
  469.     /**
  470.      * @return Collection<int, NumberOfCardCustomer>
  471.      */
  472.     public function getNumberOfCardCustomers(): Collection
  473.     {
  474.         return $this->numberOfCardCustomers;
  475.     }
  477.     public function addNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  478.     {
  479.         if (!$this->numberOfCardCustomers->contains($numberOfCardCustomer)) {
  480.             $this->numberOfCardCustomers[] = $numberOfCardCustomer;
  481.             $numberOfCardCustomer->setCustomer($this);
  482.         }
  484.         return $this;
  485.     }
  487.     public function removeNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  488.     {
  489.         if ($this->numberOfCardCustomers->removeElement($numberOfCardCustomer)) {
  490.             // set the owning side to null (unless already changed)
  491.             if ($numberOfCardCustomer->getCustomer() === $this) {
  492.                 $numberOfCardCustomer->setCustomer(null);
  493.             }
  494.         }
  496.         return $this;
  497.     }
  499.     /**
  500.      * @return Collection<int, TypeEstablishment>
  501.      */
  502.     public function getTypeEstablishments(): Collection
  503.     {
  504.         return $this->typeEstablishments;
  505.     }
  507.     public function addTypeEstablishment(TypeEstablishment $typeEstablishment): self
  508.     {
  509.         if (!$this->typeEstablishments->contains($typeEstablishment)) {
  510.             $this->typeEstablishments[] = $typeEstablishment;
  511.             $typeEstablishment->setCreatedBy($this);
  512.         }
  514.         return $this;
  515.     }
  517.     public function removeTypeEstablishment(TypeEstablishment $typeEstablishment): self
  518.     {
  519.         if ($this->typeEstablishments->removeElement($typeEstablishment)) {
  520.             // set the owning side to null (unless already changed)
  521.             if ($typeEstablishment->getCreatedBy() === $this) {
  522.                 $typeEstablishment->setCreatedBy(null);
  523.             }
  524.         }
  526.         return $this;
  527.     }
  529.     /**
  530.      * @return Collection<int, ReferenceUserEstablishment>
  531.      */
  532.     public function getReferenceUserEstablishments(): Collection
  533.     {
  534.         return $this->referenceUserEstablishments;
  535.     }
  537.     public function addReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  538.     {
  539.         if (!$this->referenceUserEstablishments->contains($referenceUserEstablishment)) {
  540.             $this->referenceUserEstablishments[] = $referenceUserEstablishment;
  541.             $referenceUserEstablishment->setUser($this);
  542.         }
  544.         return $this;
  545.     }
  547.     public function removeReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  548.     {
  549.         if ($this->referenceUserEstablishments->removeElement($referenceUserEstablishment)) {
  550.             // set the owning side to null (unless already changed)
  551.             if ($referenceUserEstablishment->getUser() === $this) {
  552.                 $referenceUserEstablishment->setUser(null);
  553.             }
  554.         }
  556.         return $this;
  557.     }
  559.     /**
  560.      * @return Collection<int, UserEstablishment>
  561.      */
  562.     public function getUserEstablishments(): Collection
  563.     {
  564.         return $this->userEstablishments;
  565.     }
  567.     public function addUserEstablishment(UserEstablishment $userEstablishment): self
  568.     {
  569.         if (!$this->userEstablishments->contains($userEstablishment)) {
  570.             $this->userEstablishments[] = $userEstablishment;
  571.             $userEstablishment->setUser($this);
  572.         }
  574.         return $this;
  575.     }
  577.     public function removeUserEstablishment(UserEstablishment $userEstablishment): self
  578.     {
  579.         if ($this->userEstablishments->removeElement($userEstablishment)) {
  580.             // set the owning side to null (unless already changed)
  581.             if ($userEstablishment->getUser() === $this) {
  582.                 $userEstablishment->setUser(null);
  583.             }
  584.         }
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, ShoppingCart>
  591.      */
  592.     public function getShoppingCarts(): Collection
  593.     {
  594.         return $this->shoppingCarts;
  595.     }
  597.     public function addShoppingCart(ShoppingCart $shoppingCart): self
  598.     {
  599.         if (!$this->shoppingCarts->contains($shoppingCart)) {
  600.             $this->shoppingCarts[] = $shoppingCart;
  601.             $shoppingCart->setCreatedBy($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeShoppingCart(ShoppingCart $shoppingCart): self
  608.     {
  609.         if ($this->shoppingCarts->removeElement($shoppingCart)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($shoppingCart->getCreatedBy() === $this) {
  612.                 $shoppingCart->setCreatedBy(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  619.     /**
  620.      * @return Collection<int, Orders>
  621.      */
  622.     public function getOrdersValidated(): Collection
  623.     {
  624.         return $this->ordersValidated;
  625.     }
  627.     public function addOrdersValidated(Orders $ordersValidated): self
  628.     {
  629.         if (!$this->ordersValidated->contains($ordersValidated)) {
  630.             $this->ordersValidated[] = $ordersValidated;
  631.             $ordersValidated->setValidatedBy($this);
  632.         }
  634.         return $this;
  635.     }
  637.     public function removeOrdersValidated(Orders $ordersValidated): self
  638.     {
  639.         if ($this->ordersValidated->removeElement($ordersValidated)) {
  640.             // set the owning side to null (unless already changed)
  641.             if ($ordersValidated->getValidatedBy() === $this) {
  642.                 $ordersValidated->setValidatedBy(null);
  643.             }
  644.         }
  646.         return $this;
  647.     }
  649.     /**
  650.      * @return Collection<int, OrderArticle>
  651.      */
  652.     public function getCreatedOrderArticle(): Collection
  653.     {
  654.         return $this->createdOrderArticle;
  655.     }
  657.     public function addCreatedOrderArticle(OrderArticle $createdOrderArticle): self
  658.     {
  659.         if (!$this->createdOrderArticle->contains($createdOrderArticle)) {
  660.             $this->createdOrderArticle[] = $createdOrderArticle;
  661.             $createdOrderArticle->setCreatedBy($this);
  662.         }
  664.         return $this;
  665.     }
  667.     public function removeCreatedOrderArticle(OrderArticle $createdOrderArticle): self
  668.     {
  669.         if ($this->createdOrderArticle->removeElement($createdOrderArticle)) {
  670.             // set the owning side to null (unless already changed)
  671.             if ($createdOrderArticle->getCreatedBy() === $this) {
  672.                 $createdOrderArticle->setCreatedBy(null);
  673.             }
  674.         }
  676.         return $this;
  677.     }
  679.     public function eraseCredentials()
  680.     {
  681.     }
  683.     public function getSalt()
  684.     {
  685.         // you *may* need a real salt depending on your encoder
  686.         // see section on salt below
  687.         return null;
  688.     }
  690.     public function getUsername()
  691.     {
  692.         return $this->email;
  693.     }
  695.     public function getRoles()
  696.     {
  697.         $ROLE = [];
  698.         foreach ($this->userEstablishments as $userEstablishment){
  699.             if($userEstablishment->getStatus()){
  700.                 $ROLE[] = 'ROLE_'.$userEstablishment->getStatus()->getDevName();
  701.             }
  703.         }
  704.         if(empty($ROLE)){
  705.             $ROLE = ["ROLE_USER"];
  706.         }
  707.         return $ROLE;
  708.     }
  710.     /** @see \Serializable::serialize() */
  711.     public function serialize()
  712.     {
  713.         return serialize(array(
  714.             $this->id,
  715.             $this->email,
  716.             $this->password,
  717.             // see section on salt below
  718.             // $this->salt,
  719.         ));
  720.     }
  722.     /** @see \Serializable::unserialize() */
  723.     public function unserialize($serialized)
  724.     {
  725.         list(
  726.             $this->id,
  727.             $this->email,
  728.             $this->password,
  729.             // see section on salt below
  730.             // $this->salt
  731.             ) = unserialize($serialized, array('allowed_classes' => false));
  732.     }
  734.     public function getRequestModification(): ?RequestModification
  735.     {
  736.         return $this->requestModification;
  737.     }
  739.     public function setRequestModification(?RequestModification $requestModification): self
  740.     {
  741.         $this->requestModification = $requestModification;
  743.         return $this;
  744.     }
  746.     /**
  747.      * @return Collection<int, RequestModification>
  748.      */
  749.     public function getRequestModifications(): Collection
  750.     {
  751.         return $this->requestModifications;
  752.     }
  754.     public function addRequestModification(RequestModification $requestModification): self
  755.     {
  756.         if (!$this->requestModifications->contains($requestModification)) {
  757.             $this->requestModifications[] = $requestModification;
  758.             $requestModification->setCreatedBy($this);
  759.         }
  761.         return $this;
  762.     }
  764.     public function removeRequestModification(RequestModification $requestModification): self
  765.     {
  766.         if ($this->requestModifications->removeElement($requestModification)) {
  767.             // set the owning side to null (unless already changed)
  768.             if ($requestModification->getCreatedBy() === $this) {
  769.                 $requestModification->setCreatedBy(null);
  770.             }
  771.         }
  773.         return $this;
  774.     }
  776.     /**
  777.      * @return Collection<int, RequestModification>
  778.      */
  779.     public function getRequestModificationsResponsable(): Collection
  780.     {
  781.         return $this->requestModificationsResponsable;
  782.     }
  784.     public function addRequestModificationsResponsable(RequestModification $requestModificationsResponsable): self
  785.     {
  786.         if (!$this->requestModificationsResponsable->contains($requestModificationsResponsable)) {
  787.             $this->requestModificationsResponsable[] = $requestModificationsResponsable;
  788.             $requestModificationsResponsable->setResponsable($this);
  789.         }
  791.         return $this;
  792.     }
  794.     public function removeRequestModificationsResponsable(RequestModification $requestModificationsResponsable): self
  795.     {
  796.         if ($this->requestModificationsResponsable->removeElement($requestModificationsResponsable)) {
  797.             // set the owning side to null (unless already changed)
  798.             if ($requestModificationsResponsable->getResponsable() === $this) {
  799.                 $requestModificationsResponsable->setResponsable(null);
  800.             }
  801.         }
  803.         return $this;
  804.     }
  806.     /**
  807.      * @return Collection<int, Establishments>
  808.      */
  809.     public function getEstablishments(): Collection
  810.     {
  811.         return $this->establishments;
  812.     }
  814.     public function addEstablishment(Establishments $establishment): self
  815.     {
  816.         if (!$this->establishments->contains($establishment)) {
  817.             $this->establishments[] = $establishment;
  818.             $establishment->setResponsable($this);
  819.         }
  821.         return $this;
  822.     }
  824.     public function removeEstablishment(Establishments $establishment): self
  825.     {
  826.         if ($this->establishments->removeElement($establishment)) {
  827.             // set the owning side to null (unless already changed)
  828.             if ($establishment->getResponsable() === $this) {
  829.                 $establishment->setResponsable(null);
  830.             }
  831.         }
  833.         return $this;
  834.     }
  836.     public function getMyResponsable(): ?self
  837.     {
  838.         return $this->myResponsable;
  839.     }
  841.     public function setMyResponsable(?self $myResponsable): self
  842.     {
  843.         $this->myResponsable = $myResponsable;
  845.         return $this;
  846.     }
  848.     /**
  849.      * @return Collection<int, self>
  850.      */
  851.     public function getMyCustomers(): Collection
  852.     {
  853.         return $this->myCustomers;
  854.     }
  856.     public function addMyCustomer(self $myCustomer): self
  857.     {
  858.         if (!$this->myCustomers->contains($myCustomer)) {
  859.             $this->myCustomers[] = $myCustomer;
  860.             $myCustomer->setMyResponsable($this);
  861.         }
  863.         return $this;
  864.     }
  866.     public function removeMyCustomer(self $myCustomer): self
  867.     {
  868.         if ($this->myCustomers->removeElement($myCustomer)) {
  869.             // set the owning side to null (unless already changed)
  870.             if ($myCustomer->getMyResponsable() === $this) {
  871.                 $myCustomer->setMyResponsable(null);
  872.             }
  873.         }
  875.         return $this;
  876.     }
  878.     public function isNotPresent(): ?bool
  879.     {
  880.         return $this->notPresent;
  881.     }
  883.     public function setNotPresent(bool $notPresent): self
  884.     {
  885.         $this->notPresent = $notPresent;
  887.         return $this;
  888.     }
  890.     public function getCity(): ?string
  891.     {
  892.         return $this->city;
  893.     }
  895.     public function setCity(string $city): self
  896.     {
  897.         $this->city = $city;
  899.         return $this;
  900.     }
  902.     public function getZip(): ?string
  903.     {
  904.         return $this->zip;
  905.     }
  907.     public function setZip(string $zip): self
  908.     {
  909.         $this->zip = $zip;
  911.         return $this;
  912.     }
  914.     public function getNumberPhone(): ?string
  915.     {
  916.         return $this->numberPhone;
  917.     }
  919.     public function setNumberPhone(string $numberPhone): self
  920.     {
  921.         $this->numberPhone = $numberPhone;
  923.         return $this;
  924.     }
  926.     /**
  927.      * @return Collection<int, Orders>
  928.      */
  929.     public function getOrders(): Collection
  930.     {
  931.         return $this->orders;
  932.     }
  934.     public function addOrder(Orders $order): self
  935.     {
  936.         if (!$this->orders->contains($order)) {
  937.             $this->orders[] = $order;
  938.             $order->setUser($this);
  939.         }
  941.         return $this;
  942.     }
  944.     public function removeOrder(Orders $order): self
  945.     {
  946.         if ($this->orders->removeElement($order)) {
  947.             // set the owning side to null (unless already changed)
  948.             if ($order->getUser() === $this) {
  949.                 $order->setUser(null);
  950.             }
  951.         }
  953.         return $this;
  954.     }
  956.     public function getPoints(): ?float
  957.     {
  958.         return $this->points;
  959.     }
  961.     public function setPoints(?float $points): self
  962.     {
  963.         $this->points = $points;
  965.         return $this;
  966.     }
  968.     /**
  969.      * @return Collection<int, ShoppingCart>
  970.      */
  971.     public function getShoppingCartsUsers(): Collection
  972.     {
  973.         return $this->shoppingCartsUsers;
  974.     }
  976.     public function addShoppingCartsUser(ShoppingCart $shoppingCartsUser): self
  977.     {
  978.         if (!$this->shoppingCartsUsers->contains($shoppingCartsUser)) {
  979.             $this->shoppingCartsUsers[] = $shoppingCartsUser;
  980.             $shoppingCartsUser->setUser($this);
  981.         }
  983.         return $this;
  984.     }
  986.     public function removeShoppingCartsUser(ShoppingCart $shoppingCartsUser): self
  987.     {
  988.         if ($this->shoppingCartsUsers->removeElement($shoppingCartsUser)) {
  989.             // set the owning side to null (unless already changed)
  990.             if ($shoppingCartsUser->getUser() === $this) {
  991.                 $shoppingCartsUser->setUser(null);
  992.             }
  993.         }
  995.         return $this;
  996.     }
  998.     /**
  999.      * @return Collection<int, ShoppingCart>
  1000.      */
  1001.     public function getShppingCartsUpdatedBy(): Collection
  1002.     {
  1003.         return $this->shppingCartsUpdatedBy;
  1004.     }
  1006.     public function addShppingCartsUpdatedBy(ShoppingCart $shppingCartsUpdatedBy): self
  1007.     {
  1008.         if (!$this->shppingCartsUpdatedBy->contains($shppingCartsUpdatedBy)) {
  1009.             $this->shppingCartsUpdatedBy[] = $shppingCartsUpdatedBy;
  1010.             $shppingCartsUpdatedBy->setUpdatedBy($this);
  1011.         }
  1013.         return $this;
  1014.     }
  1016.     public function removeShppingCartsUpdatedBy(ShoppingCart $shppingCartsUpdatedBy): self
  1017.     {
  1018.         if ($this->shppingCartsUpdatedBy->removeElement($shppingCartsUpdatedBy)) {
  1019.             // set the owning side to null (unless already changed)
  1020.             if ($shppingCartsUpdatedBy->getUpdatedBy() === $this) {
  1021.                 $shppingCartsUpdatedBy->setUpdatedBy(null);
  1022.             }
  1023.         }
  1025.         return $this;
  1026.     }
  1028.     public function getClientCard(): ?string
  1029.     {
  1030.         return $this->clientCard;
  1031.     }
  1033.     public function setClientCard(?string $clientCard): self
  1034.     {
  1035.         $this->clientCard = $clientCard;
  1036.         return $this;
  1037.     }
  1039.     public function isCgvAccepted(): ?bool
  1040.     {
  1041.         return $this->cgvAccepted;
  1042.     }
  1044.     public function setCgvAccepted(bool $cgvAccepted): self
  1045.     {
  1046.         $this->cgvAccepted = $cgvAccepted;
  1047.         return $this;
  1048.     }
  1050.     /**
  1051.      * @return Collection<int, Orders>
  1052.      */
  1053.     public function getLastPickupUpdateOrder(): Collection
  1054.     {
  1055.         return $this->lastPickupUpdateOrder;
  1056.     }
  1058.     public function addLastPickupUpdateOrder(Orders $lastPickupUpdateOrder): self
  1059.     {
  1060.         if (!$this->lastPickupUpdateOrder->contains($lastPickupUpdateOrder)) {
  1061.             $this->lastPickupUpdateOrder[] = $lastPickupUpdateOrder;
  1062.             $lastPickupUpdateOrder->setLastPickupUpdateBy($this);
  1063.         }
  1065.         return $this;
  1066.     }
  1068.     public function removeLastPickupUpdateOrder(Orders $lastPickupUpdateOrder): self
  1069.     {
  1070.         if ($this->lastPickupUpdateOrder->removeElement($lastPickupUpdateOrder)) {
  1071.             // set the owning side to null (unless already changed)
  1072.             if ($lastPickupUpdateOrder->getLastPickupUpdateBy() === $this) {
  1073.                 $lastPickupUpdateOrder->setLastPickupUpdateBy(null);
  1074.             }
  1075.         }
  1077.         return $this;
  1078.     }
  1081.     public function getGenre(): ?string
  1082.     {
  1083.         return $this->genre;
  1084.     }
  1086.     public function setGenre(?string $genre): self
  1087.     {
  1088.         $this->genre = $genre;
  1090.         return $this;
  1091.     }
  1093.     public function getAddress(): ?string
  1094.     {
  1095.         return $this->address;
  1096.     }
  1098.     public function setAddress(?string $address): self
  1099.     {
  1100.         $this->address = $address;
  1103.         return $this;
  1104.     }
  1107.     public function getTvaNumber(): ?string
  1108.     {
  1109.         return $this->TvaNumber;
  1110.     }
  1112.     public function setTvaNumber(?string $TvaNumber): self
  1113.     {
  1114.         $this->TvaNumber = $TvaNumber;
  1116.         return $this;
  1117.     }
  1119.     public function getNewPasswordCode(): ?int
  1120.     {
  1121.         return $this->newPasswordCode;
  1122.     }
  1124.     public function setNewPasswordCode(?int $newPasswordCode): self
  1125.     {
  1126.         $this->newPasswordCode = $newPasswordCode;
  1127.         return $this;
  1128.     }
  1130. public function isEmailValidated(): ?bool
  1131.     {
  1132.         return $this->emailValidated;
  1133.     }
  1135.     public function setEmailValidated(bool $emailValidated): self
  1136.     {
  1137.         $this->emailValidated = $emailValidated;
  1138.         return $this;
  1139.     }
  1141.     public function getNewPasswordCreatedAt(): ?\DateTimeInterface
  1142.     {
  1143.         return $this->newPasswordCreatedAt;
  1144.     }
  1146.     public function setNewPasswordCreatedAt(?\DateTimeInterface $newPasswordCreatedAt): self
  1147.     {
  1148.         $this->newPasswordCreatedAt = $newPasswordCreatedAt;
  1149.         return $this;
  1150.     }
  1152.     public function getEmailValidationToken(): ?string
  1153.     {
  1154.         return $this->emailValidationToken;
  1155.     }
  1157.     public function setEmailValidationToken(?string $emailValidationToken): self
  1158.     {
  1159.         $this->emailValidationToken = $emailValidationToken;
  1161.         return $this;
  1162.     }
  1164.     /**
  1165.      * @return Collection<int, Favorite>
  1166.      */
  1167.     public function getFavorites(): Collection
  1168.     {
  1169.         return $this->favorites;
  1170.     }
  1172.     public function addFavorite(Favorite $favorite): self
  1173.     {
  1174.         if (!$this->favorites->contains($favorite)) {
  1175.             $this->favorites[] = $favorite;
  1176.             $favorite->setUser($this);
  1177.         }
  1179.         return $this;
  1180.     }
  1182.     public function removeFavorite(Favorite $favorite): self
  1183.     {
  1184.         if ($this->favorites->removeElement($favorite)) {
  1185.             // set the owning side to null (unless already changed)
  1186.             if ($favorite->getUser() === $this) {
  1187.                 $favorite->setUser(null);
  1188.             }
  1189.         }
  1191.         return $this;
  1192.     }
  1194.     public function getNewPasswordToken(): ?string
  1195.     {
  1196.         return $this->newPasswordToken;
  1197.     }
  1199.     public function setNewPasswordToken(?string $newPasswordToken): self
  1200.     {
  1201.         $this->newPasswordToken = $newPasswordToken;
  1203.         return $this;
  1204.     }
  1206.     public function getStatusIntern(): ?userStatusIntern
  1207.     {
  1208.         return $this->statusIntern;
  1209.     }
  1211.     public function setStatusIntern(?userStatusIntern $statusIntern): self
  1212.     {
  1213.         $this->statusIntern = $statusIntern;
  1215.         return $this;
  1216.     }
  1218.     /**
  1219.      * @return Collection<int, Banner>
  1220.      */
  1221.     public function getBanners(): Collection
  1222.     {
  1223.         return $this->banners;
  1224.     }
  1226.     public function addBanner(Banner $banner): self
  1227.     {
  1228.         if (!$this->banners->contains($banner)) {
  1229.             $this->banners[] = $banner;
  1230.             $banner->setCreatedBy($this);
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     public function removeBanner(Banner $banner): self
  1237.     {
  1238.         if ($this->banners->removeElement($banner)) {
  1239.             // set the owning side to null (unless already changed)
  1240.             if ($banner->getCreatedBy() === $this) {
  1241.                 $banner->setCreatedBy(null);
  1242.             }
  1243.         }
  1245.         return $this;
  1246.     }
  1248.     public function getTva(): ?TVA
  1249.     {
  1250.         return $this->tva;
  1251.     }
  1253.     public function setTva(?TVA $tva): self
  1254.     {
  1255.         $this->tva = $tva;
  1257.         return $this;
  1258.     }
  1260.     public function isFirstConnexion(): ?bool
  1261.     {
  1262.         return $this->firstConnexion;
  1263.     }
  1265.     public function setFirstConnexion(bool $firstConnexion): self
  1266.     {
  1267.         $this->firstConnexion = $firstConnexion;
  1269.         return $this;
  1270.     }
  1272.     /**
  1273.      * @return Collection<int, Invoice>
  1274.      */
  1275.     public function getInvoices(): Collection
  1276.     {
  1277.         return $this->invoices;
  1278.     }
  1280.     public function addInvoice(Invoice $invoice): self
  1281.     {
  1282.         if (!$this->invoices->contains($invoice)) {
  1283.             $this->invoices[] = $invoice;
  1284.             $invoice->setUser($this);
  1285.         }
  1287.         return $this;
  1288.     }
  1290.     public function removeInvoice(Invoice $invoice): self
  1291.     {
  1292.         if ($this->invoices->removeElement($invoice)) {
  1293.             // set the owning side to null (unless already changed)
  1294.             if ($invoice->getUser() === $this) {
  1295.                 $invoice->setUser(null);
  1296.             }
  1297.         }
  1299.         return $this;
  1300.     }
  1302.     /**
  1303.      * @return Collection<int, EmailInvoice>
  1304.      */
  1305.     public function getEmailInvoices(): Collection
  1306.     {
  1307.         return $this->emailInvoices;
  1308.     }
  1310.     public function addEmailInvoice(EmailInvoice $emailInvoice): self
  1311.     {
  1312.         if (!$this->emailInvoices->contains($emailInvoice)) {
  1313.             $this->emailInvoices[] = $emailInvoice;
  1314.             $emailInvoice->setAddedBy($this);
  1315.         }
  1317.         return $this;
  1318.     }
  1320.     public function removeEmailInvoice(EmailInvoice $emailInvoice): self
  1321.     {
  1322.         if ($this->emailInvoices->removeElement($emailInvoice)) {
  1323.             // set the owning side to null (unless already changed)
  1324.             if ($emailInvoice->getAddedBy() === $this) {
  1325.                 $emailInvoice->setAddedBy(null);
  1326.             }
  1327.         }
  1329.         return $this;
  1330.     }
  1332.     /**
  1333.      * @return Collection<int, ArticleOrderOutOfStock>
  1334.      */
  1335.     public function getArticleOrderOutOfStocks(): Collection
  1336.     {
  1337.         return $this->articleOrderOutOfStocks;
  1338.     }
  1340.     public function addArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1341.     {
  1342.         if (!$this->articleOrderOutOfStocks->contains($articleOrderOutOfStock)) {
  1343.             $this->articleOrderOutOfStocks[] = $articleOrderOutOfStock;
  1344.             $articleOrderOutOfStock->setUser($this);
  1345.         }
  1347.         return $this;
  1348.     }
  1350.     public function removeArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1351.     {
  1352.         if ($this->articleOrderOutOfStocks->removeElement($articleOrderOutOfStock)) {
  1353.             // set the owning side to null (unless already changed)
  1354.             if ($articleOrderOutOfStock->getUser() === $this) {
  1355.                 $articleOrderOutOfStock->setUser(null);
  1356.             }
  1357.         }
  1359.         return $this;
  1360.     }
  1362.     /**
  1363.      * @return Collection<int, BackOrder>
  1364.      */
  1365.     public function getBackOrders(): Collection
  1366.     {
  1367.         return $this->backOrders;
  1368.     }
  1370.     public function addBackOrder(BackOrder $backOrder): self
  1371.     {
  1372.         if (!$this->backOrders->contains($backOrder)) {
  1373.             $this->backOrders[] = $backOrder;
  1374.             $backOrder->setUser($this);
  1375.         }
  1377.         return $this;
  1378.     }
  1380.     public function removeBackOrder(BackOrder $backOrder): self
  1381.     {
  1382.         if ($this->backOrders->removeElement($backOrder)) {
  1383.             // set the owning side to null (unless already changed)
  1384.             if ($backOrder->getUser() === $this) {
  1385.                 $backOrder->setUser(null);
  1386.             }
  1387.         }
  1389.         return $this;
  1390.     }
  1392.     /**
  1393.      * @return Collection<int, InvoiceDownloads>
  1394.      */
  1395.     public function getInvoiceDownloads(): Collection
  1396.     {
  1397.         return $this->invoiceDownloads;
  1398.     }
  1400.     public function addInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1401.     {
  1402.         if (!$this->invoiceDownloads->contains($invoiceDownload)) {
  1403.             $this->invoiceDownloads[] = $invoiceDownload;
  1404.             $invoiceDownload->setUser($this);
  1405.         }
  1407.         return $this;
  1408.     }
  1410.     public function removeInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1411.     {
  1412.         if ($this->invoiceDownloads->removeElement($invoiceDownload)) {
  1413.             // set the owning side to null (unless already changed)
  1414.             if ($invoiceDownload->getUser() === $this) {
  1415.                 $invoiceDownload->setUser(null);
  1416.             }
  1417.         }
  1419.         return $this;
  1420.     }
  1422.     /**
  1423.      * @return Collection<int, Articles>
  1424.      */
  1425.     public function getArticlesChangeVisibility(): Collection
  1426.     {
  1427.         return $this->articlesChangeVisibility;
  1428.     }
  1430.     public function addArticlesChangeVisibility(Articles $article): self
  1431.     {
  1432.         if (!$this->articlesChangeVisibility->contains($article)) {
  1433.             $this->articlesChangeVisibility[] = $article;
  1434.             $article->setVisibleBy($this);
  1435.         }
  1437.         return $this;
  1438.     }
  1440.     public function removeArticlesChangeVisibility(Articles $article): self
  1441.     {
  1442.         if ($this->articlesChangeVisibility->removeElement($article)) {
  1443.             // set the owning side to null (unless already changed)
  1444.             if ($article->getVisibleBy() === $this) {
  1445.                 $article->setVisibleBy(null);
  1446.             }
  1447.         }
  1449.         return $this;
  1450.     }
  1452.     /**
  1453.      * @return Collection<int, ChildTags>
  1454.      */
  1455.     public function getChildTagsUpdate(): Collection
  1456.     {
  1457.         return $this->childTagsUpdate;
  1458.     }
  1460.     public function addChildTagsUpdate(ChildTags $childTagsUpdate): self
  1461.     {
  1462.         if (!$this->childTagsUpdate->contains($childTagsUpdate)) {
  1463.             $this->childTagsUpdate[] = $childTagsUpdate;
  1464.             $childTagsUpdate->setUpdatedBy($this);
  1465.         }
  1467.         return $this;
  1468.     }
  1470.     public function removeChildTagsUpdate(ChildTags $childTagsUpdate): self
  1471.     {
  1472.         if ($this->childTagsUpdate->removeElement($childTagsUpdate)) {
  1473.             // set the owning side to null (unless already changed)
  1474.             if ($childTagsUpdate->getUpdatedBy() === $this) {
  1475.                 $childTagsUpdate->setUpdatedBy(null);
  1476.             }
  1477.         }
  1479.         return $this;
  1480.     }
  1482.     /**
  1483.      * @return Collection<int, TagGroups>
  1484.      */
  1485.     public function getTagGroupsUpdate(): Collection
  1486.     {
  1487.         return $this->TagGroupsUpdate;
  1488.     }
  1490.     public function addTagGroupsUpdate(TagGroups $tagGroupsUpdate): self
  1491.     {
  1492.         if (!$this->tagGroupsUpdate->contains($tagGroupsUpdate)) {
  1493.             $this->tagGroupsUpdate[] = $tagGroupsUpdate;
  1494.             $tagGroupsUpdate->setUpdatedBy($this);
  1495.         }
  1497.         return $this;
  1498.     }
  1500.     public function removeTagGroupsUpdate(TagGroups $tagGroupsUpdate): self
  1501.     {
  1502.         if ($this->tagGroupsUpdate->removeElement($tagGroupsUpdate)) {
  1503.             // set the owning side to null (unless already changed)
  1504.             if ($tagGroupsUpdate->getUpdatedBy() === $this) {
  1505.                 $tagGroupsUpdate->setUpdatedBy(null);
  1506.             }
  1507.         }
  1509.         return $this;
  1510.     }
  1512.     /**
  1513.      * @return Collection<int, Feedback>
  1514.      */
  1515.     public function getFeedback(): Collection
  1516.     {
  1517.         return $this->feedback;
  1518.     }
  1520.     public function addFeedback(Feedback $feedback): self
  1521.     {
  1522.         if (!$this->feedback->contains($feedback)) {
  1523.             $this->feedback[] = $feedback;
  1524.             $feedback->setUser($this);
  1525.         }
  1527.         return $this;
  1528.     }
  1530.     public function removeFeedback(Feedback $feedback): self
  1531.     {
  1532.         if ($this->feedback->removeElement($feedback)) {
  1533.             // set the owning side to null (unless already changed)
  1534.             if ($feedback->getUser() === $this) {
  1535.                 $feedback->setUser(null);
  1536.             }
  1537.         }
  1539.         return $this;
  1540.     }
  1542.     public function getDeletedAt(): ?\DateTimeInterface
  1543.     {
  1544.         return $this->deletedAt;
  1545.     }
  1547.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  1548.     {
  1549.         $this->deletedAt = $deletedAt;
  1551.         return $this;
  1552.     }
  1554.     public function getDeletedBy(): ?self
  1555.     {
  1556.         return $this->deletedBy;
  1557.     }
  1559.     public function setDeletedBy(?self $deletedBy): self
  1560.     {
  1561.         $this->deletedBy = $deletedBy;
  1563.         return $this;
  1564.     }
  1566.     public function getZendeskId(): ?string
  1567.     {
  1568.         return $this->zendeskId;
  1569.     }
  1571.     public function setZendeskId(?string $zendeskId): self
  1572.     {
  1573.         $this->zendeskId = $zendeskId;
  1575.         return $this;
  1576.     }
  1578.     public function getConnectedAt(): ?Establishments
  1579.     {
  1580.         return $this->connectedAt;
  1581.     }
  1583.     public function setConnectedAt(?Establishments $connectedAt): self
  1584.     {
  1585.         $this->connectedAt = $connectedAt;
  1587.         return $this;
  1588.     }
  1590.     /**
  1591.      * @return Collection<int, ListRestriction>
  1592.      */
  1593.     public function getListRestrictions(): Collection
  1594.     {
  1595.         return $this->listRestrictions;
  1596.     }
  1598.     public function addListRestriction(ListRestriction $listRestriction): self
  1599.     {
  1600.         if (!$this->listRestrictions->contains($listRestriction)) {
  1601.             $this->listRestrictions[] = $listRestriction;
  1602.             $listRestriction->setCreatedBy($this);
  1603.         }
  1605.         return $this;
  1606.     }
  1608.     public function removeListRestriction(ListRestriction $listRestriction): self
  1609.     {
  1610.         if ($this->listRestrictions->removeElement($listRestriction)) {
  1611.             // set the owning side to null (unless already changed)
  1612.             if ($listRestriction->getCreatedBy() === $this) {
  1613.                 $listRestriction->setCreatedBy(null);
  1614.             }
  1615.         }
  1617.         return $this;
  1618.     }
  1620.     /**
  1621.      * @return Collection<int, ListRestrictionEstablishment>
  1622.      */
  1623.     public function getGetListRestrictionEstablishmentsCreatedBy(): Collection
  1624.     {
  1625.         return $this->getListRestrictionEstablishmentsCreatedBy;
  1626.     }
  1628.     public function addGetListRestrictionEstablishmentsCreatedBy(ListRestrictionEstablishment $getListRestrictionEstablishmentsCreatedBy): self
  1629.     {
  1630.         if (!$this->getListRestrictionEstablishmentsCreatedBy->contains($getListRestrictionEstablishmentsCreatedBy)) {
  1631.             $this->getListRestrictionEstablishmentsCreatedBy[] = $getListRestrictionEstablishmentsCreatedBy;
  1632.             $getListRestrictionEstablishmentsCreatedBy->setCreatedBy($this);
  1633.         }
  1635.         return $this;
  1636.     }
  1638.     public function removeGetListRestrictionEstablishmentsCreatedBy(ListRestrictionEstablishment $getListRestrictionEstablishmentsCreatedBy): self
  1639.     {
  1640.         if ($this->getListRestrictionEstablishmentsCreatedBy->removeElement($getListRestrictionEstablishmentsCreatedBy)) {
  1641.             // set the owning side to null (unless already changed)
  1642.             if ($getListRestrictionEstablishmentsCreatedBy->getCreatedBy() === $this) {
  1643.                 $getListRestrictionEstablishmentsCreatedBy->setCreatedBy(null);
  1644.             }
  1645.         }
  1647.         return $this;
  1648.     }
  1649. }