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.     public function __construct()
  314.     {
  315.         $this->createdAt = new \DateTime();
  316.         $this->numberOfCardCustomers = new ArrayCollection();
  317.         $this->typeEstablishments = new ArrayCollection();
  318.         $this->referenceUserEstablishments = new ArrayCollection();
  319.         $this->userEstablishments = new ArrayCollection();
  320.         $this->shoppingCarts = new ArrayCollection();
  321.         $this->ordersValidated = new ArrayCollection();
  322.         $this->createdOrderArticle = new ArrayCollection();
  323.         $this->requestModifications = new ArrayCollection();
  324.         $this->requestModificationsResponsable = new ArrayCollection();
  325.         $this->establishments = new ArrayCollection();
  326.         $this->myCustomers = new ArrayCollection();
  327.         $this->orders = new ArrayCollection();
  328.         $this->shoppingCartsUsers = new ArrayCollection();
  329.         $this->shppingCartsUpdatedBy = new ArrayCollection();
  330.         $this->lastPickupUpdateOrder = new ArrayCollection();
  331.         $this->favorites = new ArrayCollection();
  332.         $this->banners = new ArrayCollection();
  333.         $this->invoices = new ArrayCollection();
  334.         $this->emailInvoices = new ArrayCollection();
  335.         $this->articleOrderOutOfStocks = new ArrayCollection();
  336.         $this->backOrders = new ArrayCollection();
  337.         $this->invoiceDownloads = new ArrayCollection();
  338.         $this->articlesChangeVisibility = new ArrayCollection();
  339.         $this->childTagsUpdate = new ArrayCollection();
  340.         $this->tagGroupsUpdate = new ArrayCollection();
  341.         $this->feedback = new ArrayCollection();
  342.     }
  344.     public function getId(): ?int
  345.     {
  346.         return $this->id;
  347.     }
  349.     public function getPassword(): ?string
  350.     {
  351.         return $this->password;
  352.     }
  354.     public function setPassword(string $password): self
  355.     {
  356.         $this->password = $password;
  358.         return $this;
  359.     }
  361.     public function getIdPunch(): ?int
  362.     {
  363.         return $this->idPunch;
  364.     }
  366.     public function setIdPunch(?int $idPunch): self
  367.     {
  368.         $this->idPunch = $idPunch;
  370.         return $this;
  371.     }
  373.     public function getFirstname(): ?string
  374.     {
  375.         return $this->firstname;
  376.     }
  378.     public function setFirstname(?string $firstname): self
  379.     {
  380.         $this->firstname = $firstname;
  382.         return $this;
  383.     }
  385.     public function getLastname(): ?string
  386.     {
  387.         return $this->lastname;
  388.     }
  390.     public function setLastname(?string $lastname): self
  391.     {
  392.         $this->lastname = $lastname;
  394.         return $this;
  395.     }
  397.     public function getEmail(): ?string
  398.     {
  399.         return $this->email;
  400.     }
  402.     public function setEmail(?string $email): self
  403.     {
  404.         $this->email = $email;
  406.         return $this;
  407.     }
  409.     public function getCreatedAt(): ?\DateTimeInterface
  410.     {
  411.         return $this->createdAt;
  412.     }
  414.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  415.     {
  416.         $this->createdAt = $createdAt;
  418.         return $this;
  419.     }
  421.     public function isDeleted(): ?bool
  422.     {
  423.         return $this->deleted;
  424.     }
  426.     public function setDeleted(bool $deleted): self
  427.     {
  428.         $this->deleted = $deleted;
  430.         return $this;
  431.     }
  433.     public function getToken(): ?string
  434.     {
  435.         return $this->token;
  436.     }
  438.     public function setToken(?string $token): self
  439.     {
  440.         $this->token = $token;
  442.         return $this;
  443.     }
  445.     public function isValidated(): ?bool
  446.     {
  447.         return $this->validated;
  448.     }
  450.     public function setValidated(bool $validated): self
  451.     {
  452.         $this->validated = $validated;
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection<int, NumberOfCardCustomer>
  459.      */
  460.     public function getNumberOfCardCustomers(): Collection
  461.     {
  462.         return $this->numberOfCardCustomers;
  463.     }
  465.     public function addNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  466.     {
  467.         if (!$this->numberOfCardCustomers->contains($numberOfCardCustomer)) {
  468.             $this->numberOfCardCustomers[] = $numberOfCardCustomer;
  469.             $numberOfCardCustomer->setCustomer($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeNumberOfCardCustomer(NumberOfCardCustomer $numberOfCardCustomer): self
  476.     {
  477.         if ($this->numberOfCardCustomers->removeElement($numberOfCardCustomer)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($numberOfCardCustomer->getCustomer() === $this) {
  480.                 $numberOfCardCustomer->setCustomer(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, TypeEstablishment>
  489.      */
  490.     public function getTypeEstablishments(): Collection
  491.     {
  492.         return $this->typeEstablishments;
  493.     }
  495.     public function addTypeEstablishment(TypeEstablishment $typeEstablishment): self
  496.     {
  497.         if (!$this->typeEstablishments->contains($typeEstablishment)) {
  498.             $this->typeEstablishments[] = $typeEstablishment;
  499.             $typeEstablishment->setCreatedBy($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeTypeEstablishment(TypeEstablishment $typeEstablishment): self
  506.     {
  507.         if ($this->typeEstablishments->removeElement($typeEstablishment)) {
  508.             // set the owning side to null (unless already changed)
  509.             if ($typeEstablishment->getCreatedBy() === $this) {
  510.                 $typeEstablishment->setCreatedBy(null);
  511.             }
  512.         }
  514.         return $this;
  515.     }
  517.     /**
  518.      * @return Collection<int, ReferenceUserEstablishment>
  519.      */
  520.     public function getReferenceUserEstablishments(): Collection
  521.     {
  522.         return $this->referenceUserEstablishments;
  523.     }
  525.     public function addReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  526.     {
  527.         if (!$this->referenceUserEstablishments->contains($referenceUserEstablishment)) {
  528.             $this->referenceUserEstablishments[] = $referenceUserEstablishment;
  529.             $referenceUserEstablishment->setUser($this);
  530.         }
  532.         return $this;
  533.     }
  535.     public function removeReferenceUserEstablishment(ReferenceUserEstablishment $referenceUserEstablishment): self
  536.     {
  537.         if ($this->referenceUserEstablishments->removeElement($referenceUserEstablishment)) {
  538.             // set the owning side to null (unless already changed)
  539.             if ($referenceUserEstablishment->getUser() === $this) {
  540.                 $referenceUserEstablishment->setUser(null);
  541.             }
  542.         }
  544.         return $this;
  545.     }
  547.     /**
  548.      * @return Collection<int, UserEstablishment>
  549.      */
  550.     public function getUserEstablishments(): Collection
  551.     {
  552.         return $this->userEstablishments;
  553.     }
  555.     public function addUserEstablishment(UserEstablishment $userEstablishment): self
  556.     {
  557.         if (!$this->userEstablishments->contains($userEstablishment)) {
  558.             $this->userEstablishments[] = $userEstablishment;
  559.             $userEstablishment->setUser($this);
  560.         }
  562.         return $this;
  563.     }
  565.     public function removeUserEstablishment(UserEstablishment $userEstablishment): self
  566.     {
  567.         if ($this->userEstablishments->removeElement($userEstablishment)) {
  568.             // set the owning side to null (unless already changed)
  569.             if ($userEstablishment->getUser() === $this) {
  570.                 $userEstablishment->setUser(null);
  571.             }
  572.         }
  574.         return $this;
  575.     }
  577.     /**
  578.      * @return Collection<int, ShoppingCart>
  579.      */
  580.     public function getShoppingCarts(): Collection
  581.     {
  582.         return $this->shoppingCarts;
  583.     }
  585.     public function addShoppingCart(ShoppingCart $shoppingCart): self
  586.     {
  587.         if (!$this->shoppingCarts->contains($shoppingCart)) {
  588.             $this->shoppingCarts[] = $shoppingCart;
  589.             $shoppingCart->setCreatedBy($this);
  590.         }
  592.         return $this;
  593.     }
  595.     public function removeShoppingCart(ShoppingCart $shoppingCart): self
  596.     {
  597.         if ($this->shoppingCarts->removeElement($shoppingCart)) {
  598.             // set the owning side to null (unless already changed)
  599.             if ($shoppingCart->getCreatedBy() === $this) {
  600.                 $shoppingCart->setCreatedBy(null);
  601.             }
  602.         }
  604.         return $this;
  605.     }
  607.     /**
  608.      * @return Collection<int, Orders>
  609.      */
  610.     public function getOrdersValidated(): Collection
  611.     {
  612.         return $this->ordersValidated;
  613.     }
  615.     public function addOrdersValidated(Orders $ordersValidated): self
  616.     {
  617.         if (!$this->ordersValidated->contains($ordersValidated)) {
  618.             $this->ordersValidated[] = $ordersValidated;
  619.             $ordersValidated->setValidatedBy($this);
  620.         }
  622.         return $this;
  623.     }
  625.     public function removeOrdersValidated(Orders $ordersValidated): self
  626.     {
  627.         if ($this->ordersValidated->removeElement($ordersValidated)) {
  628.             // set the owning side to null (unless already changed)
  629.             if ($ordersValidated->getValidatedBy() === $this) {
  630.                 $ordersValidated->setValidatedBy(null);
  631.             }
  632.         }
  634.         return $this;
  635.     }
  637.     /**
  638.      * @return Collection<int, OrderArticle>
  639.      */
  640.     public function getCreatedOrderArticle(): Collection
  641.     {
  642.         return $this->createdOrderArticle;
  643.     }
  645.     public function addCreatedOrderArticle(OrderArticle $createdOrderArticle): self
  646.     {
  647.         if (!$this->createdOrderArticle->contains($createdOrderArticle)) {
  648.             $this->createdOrderArticle[] = $createdOrderArticle;
  649.             $createdOrderArticle->setCreatedBy($this);
  650.         }
  652.         return $this;
  653.     }
  655.     public function removeCreatedOrderArticle(OrderArticle $createdOrderArticle): self
  656.     {
  657.         if ($this->createdOrderArticle->removeElement($createdOrderArticle)) {
  658.             // set the owning side to null (unless already changed)
  659.             if ($createdOrderArticle->getCreatedBy() === $this) {
  660.                 $createdOrderArticle->setCreatedBy(null);
  661.             }
  662.         }
  664.         return $this;
  665.     }
  667.     public function eraseCredentials()
  668.     {
  669.     }
  671.     public function getSalt()
  672.     {
  673.         // you *may* need a real salt depending on your encoder
  674.         // see section on salt below
  675.         return null;
  676.     }
  678.     public function getUsername()
  679.     {
  680.         return $this->email;
  681.     }
  683.     public function getRoles()
  684.     {
  685.         $ROLE = ["ROLE_USER"];
  686.         foreach ($this->userEstablishments as $userEstablishment){
  687.             if($userEstablishment->getStatus()){
  688.                 if ($userEstablishment->getStatus()->getDevName() === "ACCESS_WEB"){
  689.                     $ROLE[] = 'ROLE_ACCESS_WEB';
  690.                 }
  691.             }
  693.         }
  694.         return $ROLE;
  695.     }
  697.     /** @see \Serializable::serialize() */
  698.     public function serialize()
  699.     {
  700.         return serialize(array(
  701.             $this->id,
  702.             $this->email,
  703.             $this->password,
  704.             // see section on salt below
  705.             // $this->salt,
  706.         ));
  707.     }
  709.     /** @see \Serializable::unserialize() */
  710.     public function unserialize($serialized)
  711.     {
  712.         list(
  713.             $this->id,
  714.             $this->email,
  715.             $this->password,
  716.             // see section on salt below
  717.             // $this->salt
  718.             ) = unserialize($serialized, array('allowed_classes' => false));
  719.     }
  721.     public function getRequestModification(): ?RequestModification
  722.     {
  723.         return $this->requestModification;
  724.     }
  726.     public function setRequestModification(?RequestModification $requestModification): self
  727.     {
  728.         $this->requestModification = $requestModification;
  730.         return $this;
  731.     }
  733.     /**
  734.      * @return Collection<int, RequestModification>
  735.      */
  736.     public function getRequestModifications(): Collection
  737.     {
  738.         return $this->requestModifications;
  739.     }
  741.     public function addRequestModification(RequestModification $requestModification): self
  742.     {
  743.         if (!$this->requestModifications->contains($requestModification)) {
  744.             $this->requestModifications[] = $requestModification;
  745.             $requestModification->setCreatedBy($this);
  746.         }
  748.         return $this;
  749.     }
  751.     public function removeRequestModification(RequestModification $requestModification): self
  752.     {
  753.         if ($this->requestModifications->removeElement($requestModification)) {
  754.             // set the owning side to null (unless already changed)
  755.             if ($requestModification->getCreatedBy() === $this) {
  756.                 $requestModification->setCreatedBy(null);
  757.             }
  758.         }
  760.         return $this;
  761.     }
  763.     /**
  764.      * @return Collection<int, RequestModification>
  765.      */
  766.     public function getRequestModificationsResponsable(): Collection
  767.     {
  768.         return $this->requestModificationsResponsable;
  769.     }
  771.     public function addRequestModificationsResponsable(RequestModification $requestModificationsResponsable): self
  772.     {
  773.         if (!$this->requestModificationsResponsable->contains($requestModificationsResponsable)) {
  774.             $this->requestModificationsResponsable[] = $requestModificationsResponsable;
  775.             $requestModificationsResponsable->setResponsable($this);
  776.         }
  778.         return $this;
  779.     }
  781.     public function removeRequestModificationsResponsable(RequestModification $requestModificationsResponsable): self
  782.     {
  783.         if ($this->requestModificationsResponsable->removeElement($requestModificationsResponsable)) {
  784.             // set the owning side to null (unless already changed)
  785.             if ($requestModificationsResponsable->getResponsable() === $this) {
  786.                 $requestModificationsResponsable->setResponsable(null);
  787.             }
  788.         }
  790.         return $this;
  791.     }
  793.     /**
  794.      * @return Collection<int, Establishments>
  795.      */
  796.     public function getEstablishments(): Collection
  797.     {
  798.         return $this->establishments;
  799.     }
  801.     public function addEstablishment(Establishments $establishment): self
  802.     {
  803.         if (!$this->establishments->contains($establishment)) {
  804.             $this->establishments[] = $establishment;
  805.             $establishment->setResponsable($this);
  806.         }
  808.         return $this;
  809.     }
  811.     public function removeEstablishment(Establishments $establishment): self
  812.     {
  813.         if ($this->establishments->removeElement($establishment)) {
  814.             // set the owning side to null (unless already changed)
  815.             if ($establishment->getResponsable() === $this) {
  816.                 $establishment->setResponsable(null);
  817.             }
  818.         }
  820.         return $this;
  821.     }
  823.     public function getMyResponsable(): ?self
  824.     {
  825.         return $this->myResponsable;
  826.     }
  828.     public function setMyResponsable(?self $myResponsable): self
  829.     {
  830.         $this->myResponsable = $myResponsable;
  832.         return $this;
  833.     }
  835.     /**
  836.      * @return Collection<int, self>
  837.      */
  838.     public function getMyCustomers(): Collection
  839.     {
  840.         return $this->myCustomers;
  841.     }
  843.     public function addMyCustomer(self $myCustomer): self
  844.     {
  845.         if (!$this->myCustomers->contains($myCustomer)) {
  846.             $this->myCustomers[] = $myCustomer;
  847.             $myCustomer->setMyResponsable($this);
  848.         }
  850.         return $this;
  851.     }
  853.     public function removeMyCustomer(self $myCustomer): self
  854.     {
  855.         if ($this->myCustomers->removeElement($myCustomer)) {
  856.             // set the owning side to null (unless already changed)
  857.             if ($myCustomer->getMyResponsable() === $this) {
  858.                 $myCustomer->setMyResponsable(null);
  859.             }
  860.         }
  862.         return $this;
  863.     }
  865.     public function isNotPresent(): ?bool
  866.     {
  867.         return $this->notPresent;
  868.     }
  870.     public function setNotPresent(bool $notPresent): self
  871.     {
  872.         $this->notPresent = $notPresent;
  874.         return $this;
  875.     }
  877.     public function getCity(): ?string
  878.     {
  879.         return $this->city;
  880.     }
  882.     public function setCity(string $city): self
  883.     {
  884.         $this->city = $city;
  886.         return $this;
  887.     }
  889.     public function getZip(): ?string
  890.     {
  891.         return $this->zip;
  892.     }
  894.     public function setZip(string $zip): self
  895.     {
  896.         $this->zip = $zip;
  898.         return $this;
  899.     }
  901.     public function getNumberPhone(): ?string
  902.     {
  903.         return $this->numberPhone;
  904.     }
  906.     public function setNumberPhone(string $numberPhone): self
  907.     {
  908.         $this->numberPhone = $numberPhone;
  910.         return $this;
  911.     }
  913.     /**
  914.      * @return Collection<int, Orders>
  915.      */
  916.     public function getOrders(): Collection
  917.     {
  918.         return $this->orders;
  919.     }
  921.     public function addOrder(Orders $order): self
  922.     {
  923.         if (!$this->orders->contains($order)) {
  924.             $this->orders[] = $order;
  925.             $order->setUser($this);
  926.         }
  928.         return $this;
  929.     }
  931.     public function removeOrder(Orders $order): self
  932.     {
  933.         if ($this->orders->removeElement($order)) {
  934.             // set the owning side to null (unless already changed)
  935.             if ($order->getUser() === $this) {
  936.                 $order->setUser(null);
  937.             }
  938.         }
  940.         return $this;
  941.     }
  943.     public function getPoints(): ?float
  944.     {
  945.         return $this->points;
  946.     }
  948.     public function setPoints(?float $points): self
  949.     {
  950.         $this->points = $points;
  952.         return $this;
  953.     }
  955.     /**
  956.      * @return Collection<int, ShoppingCart>
  957.      */
  958.     public function getShoppingCartsUsers(): Collection
  959.     {
  960.         return $this->shoppingCartsUsers;
  961.     }
  963.     public function addShoppingCartsUser(ShoppingCart $shoppingCartsUser): self
  964.     {
  965.         if (!$this->shoppingCartsUsers->contains($shoppingCartsUser)) {
  966.             $this->shoppingCartsUsers[] = $shoppingCartsUser;
  967.             $shoppingCartsUser->setUser($this);
  968.         }
  970.         return $this;
  971.     }
  973.     public function removeShoppingCartsUser(ShoppingCart $shoppingCartsUser): self
  974.     {
  975.         if ($this->shoppingCartsUsers->removeElement($shoppingCartsUser)) {
  976.             // set the owning side to null (unless already changed)
  977.             if ($shoppingCartsUser->getUser() === $this) {
  978.                 $shoppingCartsUser->setUser(null);
  979.             }
  980.         }
  982.         return $this;
  983.     }
  985.     /**
  986.      * @return Collection<int, ShoppingCart>
  987.      */
  988.     public function getShppingCartsUpdatedBy(): Collection
  989.     {
  990.         return $this->shppingCartsUpdatedBy;
  991.     }
  993.     public function addShppingCartsUpdatedBy(ShoppingCart $shppingCartsUpdatedBy): self
  994.     {
  995.         if (!$this->shppingCartsUpdatedBy->contains($shppingCartsUpdatedBy)) {
  996.             $this->shppingCartsUpdatedBy[] = $shppingCartsUpdatedBy;
  997.             $shppingCartsUpdatedBy->setUpdatedBy($this);
  998.         }
  1000.         return $this;
  1001.     }
  1003.     public function removeShppingCartsUpdatedBy(ShoppingCart $shppingCartsUpdatedBy): self
  1004.     {
  1005.         if ($this->shppingCartsUpdatedBy->removeElement($shppingCartsUpdatedBy)) {
  1006.             // set the owning side to null (unless already changed)
  1007.             if ($shppingCartsUpdatedBy->getUpdatedBy() === $this) {
  1008.                 $shppingCartsUpdatedBy->setUpdatedBy(null);
  1009.             }
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function getClientCard(): ?string
  1016.     {
  1017.         return $this->clientCard;
  1018.     }
  1020.     public function setClientCard(?string $clientCard): self
  1021.     {
  1022.         $this->clientCard = $clientCard;
  1023.         return $this;
  1024.     }
  1026.     public function isCgvAccepted(): ?bool
  1027.     {
  1028.         return $this->cgvAccepted;
  1029.     }
  1031.     public function setCgvAccepted(bool $cgvAccepted): self
  1032.     {
  1033.         $this->cgvAccepted = $cgvAccepted;
  1034.         return $this;
  1035.     }
  1037.     /**
  1038.      * @return Collection<int, Orders>
  1039.      */
  1040.     public function getLastPickupUpdateOrder(): Collection
  1041.     {
  1042.         return $this->lastPickupUpdateOrder;
  1043.     }
  1045.     public function addLastPickupUpdateOrder(Orders $lastPickupUpdateOrder): self
  1046.     {
  1047.         if (!$this->lastPickupUpdateOrder->contains($lastPickupUpdateOrder)) {
  1048.             $this->lastPickupUpdateOrder[] = $lastPickupUpdateOrder;
  1049.             $lastPickupUpdateOrder->setLastPickupUpdateBy($this);
  1050.         }
  1052.         return $this;
  1053.     }
  1055.     public function removeLastPickupUpdateOrder(Orders $lastPickupUpdateOrder): self
  1056.     {
  1057.         if ($this->lastPickupUpdateOrder->removeElement($lastPickupUpdateOrder)) {
  1058.             // set the owning side to null (unless already changed)
  1059.             if ($lastPickupUpdateOrder->getLastPickupUpdateBy() === $this) {
  1060.                 $lastPickupUpdateOrder->setLastPickupUpdateBy(null);
  1061.             }
  1062.         }
  1064.         return $this;
  1065.     }
  1068.     public function getGenre(): ?string
  1069.     {
  1070.         return $this->genre;
  1071.     }
  1073.     public function setGenre(?string $genre): self
  1074.     {
  1075.         $this->genre = $genre;
  1077.         return $this;
  1078.     }
  1080.     public function getAddress(): ?string
  1081.     {
  1082.         return $this->address;
  1083.     }
  1085.     public function setAddress(?string $address): self
  1086.     {
  1087.         $this->address = $address;
  1090.         return $this;
  1091.     }
  1094.     public function getTvaNumber(): ?string
  1095.     {
  1096.         return $this->TvaNumber;
  1097.     }
  1099.     public function setTvaNumber(?string $TvaNumber): self
  1100.     {
  1101.         $this->TvaNumber = $TvaNumber;
  1103.         return $this;
  1104.     }
  1106.     public function getNewPasswordCode(): ?int
  1107.     {
  1108.         return $this->newPasswordCode;
  1109.     }
  1111.     public function setNewPasswordCode(?int $newPasswordCode): self
  1112.     {
  1113.         $this->newPasswordCode = $newPasswordCode;
  1114.         return $this;
  1115.     }
  1117. public function isEmailValidated(): ?bool
  1118.     {
  1119.         return $this->emailValidated;
  1120.     }
  1122.     public function setEmailValidated(bool $emailValidated): self
  1123.     {
  1124.         $this->emailValidated = $emailValidated;
  1125.         return $this;
  1126.     }
  1128.     public function getNewPasswordCreatedAt(): ?\DateTimeInterface
  1129.     {
  1130.         return $this->newPasswordCreatedAt;
  1131.     }
  1133.     public function setNewPasswordCreatedAt(?\DateTimeInterface $newPasswordCreatedAt): self
  1134.     {
  1135.         $this->newPasswordCreatedAt = $newPasswordCreatedAt;
  1136.         return $this;
  1137.     }
  1139.     public function getEmailValidationToken(): ?string
  1140.     {
  1141.         return $this->emailValidationToken;
  1142.     }
  1144.     public function setEmailValidationToken(?string $emailValidationToken): self
  1145.     {
  1146.         $this->emailValidationToken = $emailValidationToken;
  1148.         return $this;
  1149.     }
  1151.     /**
  1152.      * @return Collection<int, Favorite>
  1153.      */
  1154.     public function getFavorites(): Collection
  1155.     {
  1156.         return $this->favorites;
  1157.     }
  1159.     public function addFavorite(Favorite $favorite): self
  1160.     {
  1161.         if (!$this->favorites->contains($favorite)) {
  1162.             $this->favorites[] = $favorite;
  1163.             $favorite->setUser($this);
  1164.         }
  1166.         return $this;
  1167.     }
  1169.     public function removeFavorite(Favorite $favorite): self
  1170.     {
  1171.         if ($this->favorites->removeElement($favorite)) {
  1172.             // set the owning side to null (unless already changed)
  1173.             if ($favorite->getUser() === $this) {
  1174.                 $favorite->setUser(null);
  1175.             }
  1176.         }
  1178.         return $this;
  1179.     }
  1181.     public function getNewPasswordToken(): ?string
  1182.     {
  1183.         return $this->newPasswordToken;
  1184.     }
  1186.     public function setNewPasswordToken(?string $newPasswordToken): self
  1187.     {
  1188.         $this->newPasswordToken = $newPasswordToken;
  1190.         return $this;
  1191.     }
  1193.     public function getStatusIntern(): ?userStatusIntern
  1194.     {
  1195.         return $this->statusIntern;
  1196.     }
  1198.     public function setStatusIntern(?userStatusIntern $statusIntern): self
  1199.     {
  1200.         $this->statusIntern = $statusIntern;
  1202.         return $this;
  1203.     }
  1205.     /**
  1206.      * @return Collection<int, Banner>
  1207.      */
  1208.     public function getBanners(): Collection
  1209.     {
  1210.         return $this->banners;
  1211.     }
  1213.     public function addBanner(Banner $banner): self
  1214.     {
  1215.         if (!$this->banners->contains($banner)) {
  1216.             $this->banners[] = $banner;
  1217.             $banner->setCreatedBy($this);
  1218.         }
  1220.         return $this;
  1221.     }
  1223.     public function removeBanner(Banner $banner): self
  1224.     {
  1225.         if ($this->banners->removeElement($banner)) {
  1226.             // set the owning side to null (unless already changed)
  1227.             if ($banner->getCreatedBy() === $this) {
  1228.                 $banner->setCreatedBy(null);
  1229.             }
  1230.         }
  1232.         return $this;
  1233.     }
  1235.     public function getTva(): ?TVA
  1236.     {
  1237.         return $this->tva;
  1238.     }
  1240.     public function setTva(?TVA $tva): self
  1241.     {
  1242.         $this->tva = $tva;
  1244.         return $this;
  1245.     }
  1247.     public function isFirstConnexion(): ?bool
  1248.     {
  1249.         return $this->firstConnexion;
  1250.     }
  1252.     public function setFirstConnexion(bool $firstConnexion): self
  1253.     {
  1254.         $this->firstConnexion = $firstConnexion;
  1256.         return $this;
  1257.     }
  1259.     /**
  1260.      * @return Collection<int, Invoice>
  1261.      */
  1262.     public function getInvoices(): Collection
  1263.     {
  1264.         return $this->invoices;
  1265.     }
  1267.     public function addInvoice(Invoice $invoice): self
  1268.     {
  1269.         if (!$this->invoices->contains($invoice)) {
  1270.             $this->invoices[] = $invoice;
  1271.             $invoice->setUser($this);
  1272.         }
  1274.         return $this;
  1275.     }
  1277.     public function removeInvoice(Invoice $invoice): self
  1278.     {
  1279.         if ($this->invoices->removeElement($invoice)) {
  1280.             // set the owning side to null (unless already changed)
  1281.             if ($invoice->getUser() === $this) {
  1282.                 $invoice->setUser(null);
  1283.             }
  1284.         }
  1286.         return $this;
  1287.     }
  1289.     /**
  1290.      * @return Collection<int, EmailInvoice>
  1291.      */
  1292.     public function getEmailInvoices(): Collection
  1293.     {
  1294.         return $this->emailInvoices;
  1295.     }
  1297.     public function addEmailInvoice(EmailInvoice $emailInvoice): self
  1298.     {
  1299.         if (!$this->emailInvoices->contains($emailInvoice)) {
  1300.             $this->emailInvoices[] = $emailInvoice;
  1301.             $emailInvoice->setAddedBy($this);
  1302.         }
  1304.         return $this;
  1305.     }
  1307.     public function removeEmailInvoice(EmailInvoice $emailInvoice): self
  1308.     {
  1309.         if ($this->emailInvoices->removeElement($emailInvoice)) {
  1310.             // set the owning side to null (unless already changed)
  1311.             if ($emailInvoice->getAddedBy() === $this) {
  1312.                 $emailInvoice->setAddedBy(null);
  1313.             }
  1314.         }
  1316.         return $this;
  1317.     }
  1319.     /**
  1320.      * @return Collection<int, ArticleOrderOutOfStock>
  1321.      */
  1322.     public function getArticleOrderOutOfStocks(): Collection
  1323.     {
  1324.         return $this->articleOrderOutOfStocks;
  1325.     }
  1327.     public function addArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1328.     {
  1329.         if (!$this->articleOrderOutOfStocks->contains($articleOrderOutOfStock)) {
  1330.             $this->articleOrderOutOfStocks[] = $articleOrderOutOfStock;
  1331.             $articleOrderOutOfStock->setUser($this);
  1332.         }
  1334.         return $this;
  1335.     }
  1337.     public function removeArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1338.     {
  1339.         if ($this->articleOrderOutOfStocks->removeElement($articleOrderOutOfStock)) {
  1340.             // set the owning side to null (unless already changed)
  1341.             if ($articleOrderOutOfStock->getUser() === $this) {
  1342.                 $articleOrderOutOfStock->setUser(null);
  1343.             }
  1344.         }
  1346.         return $this;
  1347.     }
  1349.     /**
  1350.      * @return Collection<int, BackOrder>
  1351.      */
  1352.     public function getBackOrders(): Collection
  1353.     {
  1354.         return $this->backOrders;
  1355.     }
  1357.     public function addBackOrder(BackOrder $backOrder): self
  1358.     {
  1359.         if (!$this->backOrders->contains($backOrder)) {
  1360.             $this->backOrders[] = $backOrder;
  1361.             $backOrder->setUser($this);
  1362.         }
  1364.         return $this;
  1365.     }
  1367.     public function removeBackOrder(BackOrder $backOrder): self
  1368.     {
  1369.         if ($this->backOrders->removeElement($backOrder)) {
  1370.             // set the owning side to null (unless already changed)
  1371.             if ($backOrder->getUser() === $this) {
  1372.                 $backOrder->setUser(null);
  1373.             }
  1374.         }
  1376.         return $this;
  1377.     }
  1379.     /**
  1380.      * @return Collection<int, InvoiceDownloads>
  1381.      */
  1382.     public function getInvoiceDownloads(): Collection
  1383.     {
  1384.         return $this->invoiceDownloads;
  1385.     }
  1387.     public function addInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1388.     {
  1389.         if (!$this->invoiceDownloads->contains($invoiceDownload)) {
  1390.             $this->invoiceDownloads[] = $invoiceDownload;
  1391.             $invoiceDownload->setUser($this);
  1392.         }
  1394.         return $this;
  1395.     }
  1397.     public function removeInvoiceDownload(InvoiceDownloads $invoiceDownload): self
  1398.     {
  1399.         if ($this->invoiceDownloads->removeElement($invoiceDownload)) {
  1400.             // set the owning side to null (unless already changed)
  1401.             if ($invoiceDownload->getUser() === $this) {
  1402.                 $invoiceDownload->setUser(null);
  1403.             }
  1404.         }
  1406.         return $this;
  1407.     }
  1409.     /**
  1410.      * @return Collection<int, Articles>
  1411.      */
  1412.     public function getArticlesChangeVisibility(): Collection
  1413.     {
  1414.         return $this->articlesChangeVisibility;
  1415.     }
  1417.     public function addArticlesChangeVisibility(Articles $article): self
  1418.     {
  1419.         if (!$this->articlesChangeVisibility->contains($article)) {
  1420.             $this->articlesChangeVisibility[] = $article;
  1421.             $article->setVisibleBy($this);
  1422.         }
  1424.         return $this;
  1425.     }
  1427.     public function removeArticlesChangeVisibility(Articles $article): self
  1428.     {
  1429.         if ($this->articlesChangeVisibility->removeElement($article)) {
  1430.             // set the owning side to null (unless already changed)
  1431.             if ($article->getVisibleBy() === $this) {
  1432.                 $article->setVisibleBy(null);
  1433.             }
  1434.         }
  1436.         return $this;
  1437.     }
  1439.     /**
  1440.      * @return Collection<int, ChildTags>
  1441.      */
  1442.     public function getChildTagsUpdate(): Collection
  1443.     {
  1444.         return $this->childTagsUpdate;
  1445.     }
  1447.     public function addChildTagsUpdate(ChildTags $childTagsUpdate): self
  1448.     {
  1449.         if (!$this->childTagsUpdate->contains($childTagsUpdate)) {
  1450.             $this->childTagsUpdate[] = $childTagsUpdate;
  1451.             $childTagsUpdate->setUpdatedBy($this);
  1452.         }
  1454.         return $this;
  1455.     }
  1457.     public function removeChildTagsUpdate(ChildTags $childTagsUpdate): self
  1458.     {
  1459.         if ($this->childTagsUpdate->removeElement($childTagsUpdate)) {
  1460.             // set the owning side to null (unless already changed)
  1461.             if ($childTagsUpdate->getUpdatedBy() === $this) {
  1462.                 $childTagsUpdate->setUpdatedBy(null);
  1463.             }
  1464.         }
  1466.         return $this;
  1467.     }
  1469.     /**
  1470.      * @return Collection<int, TagGroups>
  1471.      */
  1472.     public function getTagGroupsUpdate(): Collection
  1473.     {
  1474.         return $this->TagGroupsUpdate;
  1475.     }
  1477.     public function addTagGroupsUpdate(TagGroups $tagGroupsUpdate): self
  1478.     {
  1479.         if (!$this->tagGroupsUpdate->contains($tagGroupsUpdate)) {
  1480.             $this->tagGroupsUpdate[] = $tagGroupsUpdate;
  1481.             $tagGroupsUpdate->setUpdatedBy($this);
  1482.         }
  1484.         return $this;
  1485.     }
  1487.     public function removeTagGroupsUpdate(TagGroups $tagGroupsUpdate): self
  1488.     {
  1489.         if ($this->tagGroupsUpdate->removeElement($tagGroupsUpdate)) {
  1490.             // set the owning side to null (unless already changed)
  1491.             if ($tagGroupsUpdate->getUpdatedBy() === $this) {
  1492.                 $tagGroupsUpdate->setUpdatedBy(null);
  1493.             }
  1494.         }
  1496.         return $this;
  1497.     }
  1499.     /**
  1500.      * @return Collection<int, Feedback>
  1501.      */
  1502.     public function getFeedback(): Collection
  1503.     {
  1504.         return $this->feedback;
  1505.     }
  1507.     public function addFeedback(Feedback $feedback): self
  1508.     {
  1509.         if (!$this->feedback->contains($feedback)) {
  1510.             $this->feedback[] = $feedback;
  1511.             $feedback->setUser($this);
  1512.         }
  1514.         return $this;
  1515.     }
  1517.     public function removeFeedback(Feedback $feedback): self
  1518.     {
  1519.         if ($this->feedback->removeElement($feedback)) {
  1520.             // set the owning side to null (unless already changed)
  1521.             if ($feedback->getUser() === $this) {
  1522.                 $feedback->setUser(null);
  1523.             }
  1524.         }
  1526.         return $this;
  1527.     }
  1529.     public function getDeletedAt(): ?\DateTimeInterface
  1530.     {
  1531.         return $this->deletedAt;
  1532.     }
  1534.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  1535.     {
  1536.         $this->deletedAt = $deletedAt;
  1538.         return $this;
  1539.     }
  1541.     public function getDeletedBy(): ?self
  1542.     {
  1543.         return $this->deletedBy;
  1544.     }
  1546.     public function setDeletedBy(?self $deletedBy): self
  1547.     {
  1548.         $this->deletedBy = $deletedBy;
  1550.         return $this;
  1551.     }
  1553.     public function getZendeskId(): ?string
  1554.     {
  1555.         return $this->zendeskId;
  1556.     }
  1558.     public function setZendeskId(?string $zendeskId): self
  1559.     {
  1560.         $this->zendeskId = $zendeskId;
  1562.         return $this;
  1563.     }
  1565.     public function getConnectedAt(): ?Establishments
  1566.     {
  1567.         return $this->connectedAt;
  1568.     }
  1570.     public function setConnectedAt(?Establishments $connectedAt): self
  1571.     {
  1572.         $this->connectedAt = $connectedAt;
  1574.         return $this;
  1575.     }
  1576. }