src/Entity/User.php line 28

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Serializable;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Repository\UserRepository;
  8. use Doctrine\Common\Collections\Collection;
  9. use Symfony\Component\HttpFoundation\File\File;
  10. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  15. use Andante\SoftDeletableBundle\SoftDeletable\SoftDeletableTrait;
  17. use Andante\SoftDeletableBundle\SoftDeletable\SoftDeletableInterface;
  18. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  20. /**
  21.  * @ORM\Entity(repositoryClass=UserRepository::class)
  22.  * @UniqueEntity(
  23.  * fields= {"email"},
  24.  * message= "Email déjà existe"
  25.  * )
  26.  * @Vich\Uploadable
  27.  */
  28. class User implements UserInterface, PasswordAuthenticatedUserInterface, \Serializable, SoftDeletableInterface
  29. {
  30.     use SoftDeletableTrait;
  32.     /**
  33.      * @ORM\Id
  34.      * @ORM\GeneratedValue
  35.      * @ORM\Column(type="integer")
  36.      */
  37.     private $id;
  39.     /**
  40.      * @ORM\Column(type="string", length=180, unique=true, nullable=true)
  41.      * @Assert\Email(message = "The email '{{ value }}' is not a valid email.")
  42.      */
  43.     private $email;
  45.     /**
  46.      * @ORM\Column(type="json")
  47.      */
  48.     private $roles = [];
  50.     /**
  51.      * @var string The hashed password
  52.      * @ORM\Column(type="string")
  53.      * @Assert\Length(min="8", minMessage="8 caracteres minimum")
  54.      */
  55.     private $password;
  57.     /**
  58.      * Undocumented variable
  59.      * @Assert\EqualTo(propertyPath="password", message="Mot de passe different")
  60.      * @var [type]
  61.      */
  62.     public $confirm_password;
  64.     /**
  65.      * @ORM\Column(type="string", length=255, nullable=true)
  66.      */
  67.     private $designation;
  69.     /**
  70.      * @ORM\Column(type="string", length=255, nullable=true, unique=true)
  71.      */
  72.     private $phone;
  74.     /**
  75.      * @ORM\Column(type="string", length=255, nullable=true)
  76.      */
  77.     private $phonetwo;
  79.     /**
  80.      * @ORM\Column(type="string", length=255, nullable=true)
  81.      */
  82.     private $phonethree;
  84.     /**
  85.      * @ORM\Column(type="text", nullable=true)
  86.      */
  87.     private $ordre;
  89.     /**
  90.      * @ORM\Column(type="boolean")
  91.      */
  92.     private $is_active = false;
  94.     /**
  95.      * @ORM\Column(type="string", length=255, nullable=true)
  96.      */
  97.     private $firstname;
  99.     /**
  100.      * @ORM\Column(type="string", length=255, nullable=true)
  101.      */
  102.     private $lastname;
  104.     /**
  105.      * @ORM\Column(type="datetime", nullable=true)
  106.      */
  107.     private $is_acceptcgv;
  109.     /**
  110.      * @ORM\Column(type="string", length=255, nullable=true)
  111.      */
  112.     private $address;
  114.     /**
  115.      * @ORM\Column(type="string", length=255, nullable=true)
  116.      */
  117.     private $pays;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity=Proposition::class, mappedBy="user")
  122.      */
  123.     private $propositions;
  125.     /**
  126.      * @ORM\ManyToOne(targetEntity=Speciality::class, inversedBy="users")
  127.      */
  128.     private $speciality;
  130.     /**
  131.      * @ORM\OneToMany(targetEntity=Order::class, mappedBy="user")
  132.      */
  133.     private $orders;
  135.     /**
  136.      * @ORM\ManyToOne(targetEntity=Ville::class, inversedBy="users")
  137.      * @ORM\JoinColumn(nullable=true)
  138.      */
  139.     private $ville;
  141.     /**
  142.      * @ORM\ManyToOne(targetEntity=Quartier::class, inversedBy="users")
  143.      * @ORM\JoinColumn(nullable=true)
  144.      */
  145.     private $quartier;
  147.     /**
  148.      * @ORM\OneToMany(targetEntity=GroupSuggestion::class, mappedBy="user")
  149.      */
  150.     private $groupSuggestions;
  152.     /**
  153.      * @ORM\OneToMany(targetEntity=Order::class, mappedBy="grossiste")
  154.      */
  155.     private $ordersGrossistes;
  157.     /**
  158.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="users")
  159.      */
  160.     private $grossiste;
  162.     /**
  163.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="grossiste")
  164.      */
  165.     private $users;
  167.     /**
  168.      * @ORM\OneToMany(targetEntity=Cart::class, mappedBy="user")
  169.      */
  170.     private $carts;
  172.     /**
  173.      * @ORM\OneToMany(targetEntity=Stockpharmacie::class, mappedBy="user", orphanRemoval=true)
  174.      */
  175.     private $stockpharmacies;
  177.     /**
  178.      * @ORM\OneToMany(targetEntity=HistoriqueRefusProposition::class, mappedBy="pharmcie")
  179.      */
  180.     private $historiqueRefusPropositions;
  182.     /**
  183.      * @ORM\ManyToOne(targetEntity=Pays::class, inversedBy="users")
  184.      * @ORM\OrderBy({"name" = "ASC"})
  185.      */
  186.     private $payslocalisation;
  188.     /**
  189.      * @ORM\Column(type="string", length=255, nullable=true)
  190.      */
  191.     private $urlexcelcmd;
  193.     /**
  194.      * @ORM\Column(type="boolean", nullable=true)
  195.      */
  196.     private $isPaid;
  198.     /**
  199.      * @ORM\OneToMany(targetEntity=Discution::class, mappedBy="user")
  200.      */
  201.     private $discutions;
  203.     /**
  204.      * @ORM\OneToMany(targetEntity=Reclamation::class, mappedBy="user", orphanRemoval=true)
  205.      */
  206.     private $reclamations;
  208.     /**
  209.      * @ORM\Column(type="string", length=255, nullable=true)
  210.      */
  211.     private $image;
  213.     /**
  214.      * @Vich\UploadableField(mapping="user_image", fileNameProperty="image")
  215.      * @var File|null
  216.      * @Assert\Image(
  217.      * mimeTypes = {"image/jpeg", "image/gif", "image/png", "image/jpg"},
  218.      * )
  219.      */
  220.     private $imageFile;
  222.     /**
  223.      * @ORM\Column(type="datetime", nullable=true)
  224.      */
  225.     private $updatedAt;
  227.     /**
  228.      * @ORM\Column(type="string", length=255, nullable=true)
  229.      */
  230.     private $verificationCode;
  232.     /**
  233.      * @ORM\Column(type="integer", nullable=true)
  234.      */
  235.     private $verified;
  237.     /**
  238.      * @ORM\OneToMany(targetEntity=Forecast::class, mappedBy="user")
  239.      */
  240.     private $forecasts;
  242.     /**
  243.      * @ORM\OneToMany(targetEntity=UserTypepaiement::class, mappedBy="users")
  244.      */
  245.     private $userTypepaiements;
  247.     /**
  248.      * 
  249.      */
  250.     private $typepaiements;
  252.     /**
  253.      * @ORM\OneToMany(targetEntity=HistoriquePaiement::class, mappedBy="user")
  254.      */
  255.     private $historiquePaiements;
  257.     /**
  258.      * @ORM\OneToMany(targetEntity=Forecast::class, mappedBy="grossiste")
  259.      */
  260.     private $instances_forecasts;
  262.     /**
  263.      * @ORM\ManyToOne(targetEntity=IctusPharmacie::class, inversedBy="users", cascade={"persist"})
  264.      */
  265.     private $ictusPharmacie;
  267.     /**
  268.      * @ORM\OneToMany(targetEntity=IctusPanierPatient::class, mappedBy="user")
  269.      */
  270.     private $ictusPanierPatients;
  272.     /**
  273.      * @ORM\OneToMany(targetEntity=IctusCommande::class, mappedBy="user")
  274.      */
  275.     private $ictusCommandes;
  277.     /**
  278.      * @ORM\Column(type="float", nullable=true)
  279.      */
  280.     private $latitude;
  282.     /**
  283.      * @ORM\Column(type="float", nullable=true)
  284.      */
  285.     private $logitude;
  287.     /**
  288.      * @ORM\OneToMany(targetEntity=IctoRemboursement::class, mappedBy="payeur")
  289.      */
  290.     private $ictoRemboursements;
  292.     /**
  293.      * @ORM\Column(type="datetime", nullable=true)
  294.      */
  295.     private $cguaccepted;
  297.     /**
  298.      * @ORM\Column(type="boolean", nullable=true)
  299.      */
  300.     private $isAdmin;
  302.     /**
  303.      * @ORM\Column(type="string", length=255, nullable=true)
  304.      */
  305.     private $CIN;
  307.     /**
  308.      * @ORM\OneToMany(targetEntity=Ordonnance::class, mappedBy="propriertaire", orphanRemoval=true)
  309.      */
  310.     private $ordonnances;
  312.     /**
  313.      * @ORM\OneToMany(targetEntity=Adresse::class, mappedBy="patient")
  314.      */
  315.     private $adresses;
  317.     /**
  318.      * @ORM\ManyToOne(targetEntity=SocieteLivraison::class, inversedBy="users")
  319.      */
  320.     private $societeLivraison;
  322.     /**
  323.      * @ORM\Column(type="string", length=255, nullable=true)
  324.      */
  325.     private $reinitmdp;
  327.     /**
  328.      * @ORM\Column(type="string", length=255, nullable=true)
  329.      */
  330.     private $validate_code;
  332.     /**
  333.      * @ORM\Column(type="datetime", nullable=true)
  334.      */
  335.     private $expiredreinitmdp;
  337.     /**
  338.      * @ORM\OneToMany(targetEntity=IctusPanierSpecial::class, mappedBy="user", orphanRemoval=true)
  339.      */
  340.     private $ictusPanierSpecials;
  342.     /**
  343.      * @ORM\OneToMany(targetEntity=CommandeSpecial::class, mappedBy="grossiste")
  344.      */
  345.     private $commandeSpecials;
  347.     /**
  348.      * @ORM\OneToMany(targetEntity=CommandeSpecial::class, mappedBy="user")
  349.      */
  350.     private $commandeSpecialsIctus;
  352.     /**
  353.      * @ORM\OneToMany(targetEntity=NonDisponibilite::class, mappedBy="livreur")
  354.      */
  355.     private $nonDisponibilites;
  357.     /**
  358.      * @ORM\OneToMany(targetEntity=FacturePatient::class, mappedBy="User", orphanRemoval=true)
  359.      */
  360.     private $facturePatients;
  362.     /**
  363.      * @ORM\Column(type="string", length=255, nullable=true)
  364.      */
  365.     private $referenceClientTP;
  367.     /**
  368.      * @ORM\Column(type="string", length=255, nullable=true)
  369.      */
  370.     private $societename;
  372.     /**
  373.      * @ORM\Column(type="date", nullable=true)
  374.      */
  375.     private $datenaissance;
  377.     /**
  378.      * @ORM\Column(type="string", length=255, nullable=true)
  379.      */
  380.     private $fcm_token;
  382.     /**
  383.      * @ORM\OneToMany(targetEntity=IctusReclamation::class, mappedBy="user", orphanRemoval=true)
  384.      */
  385.     private $ictusReclamations;
  387.     /**
  388.      * @ORM\OneToMany(targetEntity=IctusMobileAppareil::class, mappedBy="user", orphanRemoval=true)
  389.      */
  390.     private $ictusMobileAppareils;
  392.     /* 
  393.      * @ORM\OneToMany(targetEntity=Livraison::class, mappedBy="livreur")
  394.      */
  395.     private $livraisons;
  397.     /**
  398.      * @ORM\OneToMany(targetEntity=Parcours::class, mappedBy="patient")
  399.      */
  400.     private $parcours;
  402.     /**
  403.      * @ORM\OneToMany(targetEntity=Photo::class, mappedBy="creator")
  404.      */
  405.     private $photoscreate;
  407.     /**
  408.      * @ORM\Column(type="integer", nullable=true)
  409.      */
  410.     private $rangphoto;
  412.     /**
  413.      * @ORM\Column(type="string", length=255, nullable=true)
  414.      */
  415.     private $serviceSopharmad;
  417.     /**
  418.      * @ORM\OneToMany(targetEntity=IctoMouvement::class, mappedBy="user")
  419.      */
  420.     private $ictoMouvements;
  422.     /**
  423.      * @ORM\OneToMany(targetEntity=Doublon::class, mappedBy="user")
  424.      */
  425.     private $doublons;
  427.     /**
  428.      * @ORM\OneToMany(targetEntity=Rate::class, mappedBy="user", orphanRemoval=true)
  429.      */
  430.     private $rates;
  432.     /**
  433.      * @ORM\OneToMany(targetEntity=SearchHistory::class, mappedBy="user")
  434.      */
  435.     private $searchHistories;
  437.     /**
  438.      * @ORM\ManyToOne(targetEntity=IctusTypeLivraison::class, inversedBy="users")
  439.      */
  440.     private $lastTypeLivraison;
  442.     /**
  443.      * @ORM\ManyToOne(targetEntity=IctusTypePaiement::class, inversedBy="users")
  444.      */
  445.     private $lastTypePaiement;
  447.     /**
  448.      * @ORM\OneToMany(targetEntity=RemiseUserPharmacie::class, mappedBy="user")
  449.      */
  450.     private $remiseUserPharmacies;
  452.     /**
  453.      * @ORM\Column(type="boolean", nullable=true)
  454.      */
  455.     private $isRemiseAuto;
  457.     /**
  458.      * @ORM\OneToMany(targetEntity=Parrainage::class, mappedBy="user", orphanRemoval=true)
  459.      */
  460.     private $parrainages;
  462.     /**
  463.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="user", orphanRemoval=true)
  464.      */
  465.     private $favorites;
  467.     /**
  468.      * @ORM\OneToMany(targetEntity=Carte::class, mappedBy="user", orphanRemoval=true)
  469.      */
  470.     private $cartes;
  472.     /**
  473.      * @ORM\OneToMany(targetEntity=CertCertificat::class, mappedBy="user", orphanRemoval=true)
  474.      */
  475.     private $certCertificats;
  477.     /**
  478.      * @ORM\Column(type="integer", nullable=true)
  479.      */
  480.     private $sexe;
  482.     /**
  483.      * @ORM\Column(type="string", length=255, nullable=true)
  484.      */
  485.     private $codeParrainageOther;
  487.     /**
  488.      * @ORM\Column(type="string", length=255, nullable=true)
  489.      */
  490.     private $codeParrainageMine;
  492.     /**
  493.      * @ORM\Column(type="string", length=255, nullable=true)
  494.      */
  495.     private $prefixNumber;
  497.     /**
  498.      * @ORM\Column(type="boolean", nullable=true)
  499.      */
  500.     private $isDisponible;
  502.     public function __construct()
  503.     {
  504.         $this->propositions                   = new ArrayCollection();
  505.         $this->orders                         = new ArrayCollection();
  506.         $this->groupSuggestions               = new ArrayCollection();
  507.         $this->ordersGrossistes               = new ArrayCollection();
  508.         $this->users                          = new ArrayCollection();
  509.         $this->carts                          = new ArrayCollection();
  510.         $this->stockpharmacies                = new ArrayCollection();
  511.         $this->historiqueRefusPropositions    = new ArrayCollection();
  512.         $this->discutions                     = new ArrayCollection();
  513.         $this->reclamations                   = new ArrayCollection();
  514.         $this->forecasts                      = new ArrayCollection();
  515.         $this->userTypepaiements              = new ArrayCollection();
  516.         $this->historiquePaiements            = new ArrayCollection();
  517.         $this->instances_forecasts            = new ArrayCollection();
  518.         $this->ictusPanierPatients            = new ArrayCollection();
  519.         $this->ictusCommandes                 = new ArrayCollection();
  520.         $this->ictoRemboursements             = new ArrayCollection();
  521.         $this->is_acceptcgv                   = new \DateTime();
  522.         $this->cguaccepted                    = new \DateTime();
  523.         $this->ordonnances = new ArrayCollection();
  524.         $this->adresses = new ArrayCollection();
  525.         $this->ictusPanierSpecials = new ArrayCollection();
  526.         $this->commandeSpecials = new ArrayCollection();
  527.         $this->commandeSpecialsIctus = new ArrayCollection();
  528.         $this->nonDisponibilites = new ArrayCollection();
  529.         $this->facturePatients = new ArrayCollection();
  530.         $this->ictusReclamations = new ArrayCollection();
  531.         $this->ictusMobileAppareils = new ArrayCollection();
  532.         $this->livraisons = new ArrayCollection();
  533.         $this->parcours = new ArrayCollection();
  534.         $this->photoscreate = new ArrayCollection();
  535.         $this->ictoMouvements = new ArrayCollection();
  536.         $this->doublons = new ArrayCollection();
  537.         $this->rates = new ArrayCollection();
  538.         $this->searchHistories = new ArrayCollection();
  539.         $this->remiseUserPharmacies = new ArrayCollection();
  540.         $this->parrainages = new ArrayCollection();
  541.         $this->favorites = new ArrayCollection();
  542.         $this->cartes = new ArrayCollection();
  543.         $this->certCertificats = new ArrayCollection();
  544.     }
  546.     public function getNomComplet()
  547.     {
  548.         return $this->firstname . ' ' . $this->lastname;
  549.     }
  551.     public function getId(): ?int
  552.     {
  553.         return $this->id;
  554.     }
  556.     public function getEmail(): ?string
  557.     {
  558.         return $this->email;
  559.     }
  561.     public function setEmail(?string $email): self
  562.     {
  563.         $this->email = $email;
  565.         return $this;
  566.     }
  568.     /**
  569.      * A visual identifier that represents this user.
  570.      *
  571.      * @see UserInterface
  572.      */
  573.     public function getUserIdentifier(): ?string
  574.     {
  575.         return (string) $this->email;
  576.     }
  578.     /**
  579.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  580.      */
  581.     public function getUsername(): ?string
  582.     {
  583.         return (string) $this->email;
  584.     }
  586.     /**
  587.      * @see UserInterface
  588.      */
  589.     public function getRoles(): array
  590.     {
  591.         $roles = $this->roles;
  592.         // guarantee every user at least has ROLE_USER
  593.         $roles[] = 'ROLE_USER';
  595.         return array_unique($roles);
  596.     }
  598.     public function setRoles(array $roles): self
  599.     {
  600.         $this->roles = $roles;
  602.         return $this;
  603.     }
  605.     /**
  606.      * @see PasswordAuthenticatedUserInterface
  607.      */
  608.     public function getPassword(): string
  609.     {
  610.         return $this->password;
  611.     }
  613.     public function setPassword(string $password): self
  614.     {
  615.         $this->password = $password;
  617.         return $this;
  618.     }
  620.     /**
  621.      * Returning a salt is only needed, if you are not using a modern
  622.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  623.      *
  624.      * @see UserInterface
  625.      */
  626.     public function getSalt(): ?string
  627.     {
  628.         return null;
  629.     }
  631.     /**
  632.      * @see UserInterface
  633.      */
  634.     public function eraseCredentials() {}
  636.     public function getDesignation(): ?string
  637.     {
  638.         return $this->designation;
  639.     }
  641.     public function setDesignation(?string $designation): self
  642.     {
  643.         $this->designation = $designation;
  645.         return $this;
  646.     }
  648.     public function getPhone(): ?string
  649.     {
  650.         return $this->phone;
  651.     }
  653.     public function setPhone(?string $phone): self
  654.     {
  655.         $this->phone = $phone;
  657.         return $this;
  658.     }
  660.     public function getPhonetwo(): ?string
  661.     {
  662.         return $this->phonetwo;
  663.     }
  665.     public function setPhonetwo(?string $phonetwo): self
  666.     {
  667.         $this->phonetwo = $phonetwo;
  669.         return $this;
  670.     }
  672.     public function getPhonethree(): ?string
  673.     {
  674.         return $this->phonethree;
  675.     }
  677.     public function setPhonethree(?string $phonethree): self
  678.     {
  679.         $this->phonethree = $phonethree;
  681.         return $this;
  682.     }
  684.     public function getOrdre(): ?string
  685.     {
  686.         return $this->ordre;
  687.     }
  689.     public function setOrdre(?string $ordre): self
  690.     {
  691.         $this->ordre = $ordre;
  693.         return $this;
  694.     }
  696.     public function getIsActive(): ?bool
  697.     {
  698.         return $this->is_active;
  699.     }
  701.     public function setIsActive(bool $is_active): self
  702.     {
  703.         $this->is_active = $is_active;
  705.         return $this;
  706.     }
  708.     public function getFirstname(): ?string
  709.     {
  710.         return $this->firstname;
  711.     }
  713.     public function setFirstname(?string $firstname): self
  714.     {
  715.         $this->firstname = $firstname;
  717.         return $this;
  718.     }
  720.     public function getLastname(): ?string
  721.     {
  722.         return $this->lastname;
  723.     }
  725.     public function setLastname(?string $lastname): self
  726.     {
  727.         $this->lastname = $lastname;
  729.         return $this;
  730.     }
  732.     public function getFullName()
  733.     {
  734.         return $this->firstname . ' ' . $this->lastname;
  735.     }
  737.     public function getIsAcceptcgv(): ?\DateTimeInterface
  738.     {
  739.         return $this->is_acceptcgv;
  740.     }
  742.     public function setIsAcceptcgv(?\DateTimeInterface $is_acceptcgv): self
  743.     {
  744.         $this->is_acceptcgv = $is_acceptcgv;
  746.         return $this;
  747.     }
  749.     public function getAddress(): ?string
  750.     {
  751.         return $this->address;
  752.     }
  754.     public function getCompleteAddress()
  755.     {
  756.         return $this->address . ', ' . $this->getQuartier() . ', ' . $this->getVille();
  757.     }
  759.     public function setAddress(?string $address): self
  760.     {
  761.         $this->address = $address;
  763.         return $this;
  764.     }
  766.     public function getPays(): ?string
  767.     {
  768.         return $this->pays;
  769.     }
  771.     public function setPays(?string $pays): self
  772.     {
  773.         $this->pays = $pays;
  775.         return $this;
  776.     }
  779.     /**
  780.      * @return Collection<int, Proposition>
  781.      */
  782.     public function getPropositions(): Collection
  783.     {
  784.         return $this->propositions;
  785.     }
  787.     public function addProposition(Proposition $proposition): self
  788.     {
  789.         if (!$this->propositions->contains($proposition)) {
  790.             $this->propositions[] = $proposition;
  791.             $proposition->setUser($this);
  792.         }
  794.         return $this;
  795.     }
  797.     public function removeProposition(Proposition $proposition): self
  798.     {
  799.         if ($this->propositions->removeElement($proposition)) {
  800.             // set the owning side to null (unless already changed)
  801.             if ($proposition->getUser() === $this) {
  802.                 $proposition->setUser(null);
  803.             }
  804.         }
  806.         return $this;
  807.     }
  809.     public function getSpeciality(): ?Speciality
  810.     {
  811.         return $this->speciality;
  812.     }
  814.     public function setSpeciality(?Speciality $speciality): self
  815.     {
  816.         $this->speciality = $speciality;
  818.         return $this;
  819.     }
  821.     /**
  822.      * @return Collection<int, Order>
  823.      */
  824.     public function getOrders(): Collection
  825.     {
  826.         return $this->orders;
  827.     }
  829.     public function addOrder(Order $order): self
  830.     {
  831.         if (!$this->orders->contains($order)) {
  832.             $this->orders[] = $order;
  833.             $order->setUser($this);
  834.         }
  836.         return $this;
  837.     }
  839.     public function removeOrder(Order $order): self
  840.     {
  841.         if ($this->orders->removeElement($order)) {
  842.             // set the owning side to null (unless already changed)
  843.             if ($order->getUser() === $this) {
  844.                 $order->setUser(null);
  845.             }
  846.         }
  848.         return $this;
  849.     }
  851.     public function getVille(): ?Ville
  852.     {
  853.         return $this->ville;
  854.     }
  856.     public function setVille(?Ville $ville): self
  857.     {
  858.         $this->ville = $ville;
  860.         return $this;
  861.     }
  863.     public function getQuartier(): ?Quartier
  864.     {
  865.         return $this->quartier;
  866.     }
  868.     public function setQuartier(?Quartier $quartier): self
  869.     {
  870.         $this->quartier = $quartier;
  872.         return $this;
  873.     }
  875.     /**
  876.      * @return Collection<int, GroupSuggestion>
  877.      */
  878.     public function getGroupSuggestions(): Collection
  879.     {
  880.         return $this->groupSuggestions;
  881.     }
  883.     public function addGroupSuggestion(GroupSuggestion $groupSuggestion): self
  884.     {
  885.         if (!$this->groupSuggestions->contains($groupSuggestion)) {
  886.             $this->groupSuggestions[] = $groupSuggestion;
  887.             $groupSuggestion->setUser($this);
  888.         }
  890.         return $this;
  891.     }
  893.     public function removeGroupSuggestion(GroupSuggestion $groupSuggestion): self
  894.     {
  895.         if ($this->groupSuggestions->removeElement($groupSuggestion)) {
  896.             // set the owning side to null (unless already changed)
  897.             if ($groupSuggestion->getUser() === $this) {
  898.                 $groupSuggestion->setUser(null);
  899.             }
  900.         }
  902.         return $this;
  903.     }
  905.     /**
  906.      * @return Collection<int, Order>
  907.      */
  908.     public function getOrdersGrossistes(): Collection
  909.     {
  910.         return $this->ordersGrossistes;
  911.     }
  913.     public function addOrdersGrossiste(Order $ordersGrossiste): self
  914.     {
  915.         if (!$this->ordersGrossistes->contains($ordersGrossiste)) {
  916.             $this->ordersGrossistes[] = $ordersGrossiste;
  917.             $ordersGrossiste->setGrossiste($this);
  918.         }
  920.         return $this;
  921.     }
  923.     public function removeOrdersGrossiste(Order $ordersGrossiste): self
  924.     {
  925.         if ($this->ordersGrossistes->removeElement($ordersGrossiste)) {
  926.             // set the owning side to null (unless already changed)
  927.             if ($ordersGrossiste->getGrossiste() === $this) {
  928.                 $ordersGrossiste->setGrossiste(null);
  929.             }
  930.         }
  932.         return $this;
  933.     }
  935.     public function getGrossiste(): ?self
  936.     {
  937.         return $this->grossiste;
  938.     }
  940.     public function setGrossiste(?self $grossiste): self
  941.     {
  942.         $this->grossiste = $grossiste;
  944.         return $this;
  945.     }
  947.     /**
  948.      * @return Collection<int, self>
  949.      */
  950.     public function getUsers(): Collection
  951.     {
  952.         return $this->users;
  953.     }
  955.     public function addUser(self $user): self
  956.     {
  957.         if (!$this->users->contains($user)) {
  958.             $this->users[] = $user;
  959.             $user->setGrossiste($this);
  960.         }
  962.         return $this;
  963.     }
  965.     public function removeUser(self $user): self
  966.     {
  967.         if ($this->users->removeElement($user)) {
  968.             // set the owning side to null (unless already changed)
  969.             if ($user->getGrossiste() === $this) {
  970.                 $user->setGrossiste(null);
  971.             }
  972.         }
  974.         return $this;
  975.     }
  977.     /**
  978.      * @return Collection<int, Cart>
  979.      */
  980.     public function getCarts(): Collection
  981.     {
  982.         return $this->carts;
  983.     }
  985.     public function addCart(Cart $cart): self
  986.     {
  987.         if (!$this->carts->contains($cart)) {
  988.             $this->carts[] = $cart;
  989.             $cart->setUser($this);
  990.         }
  992.         return $this;
  993.     }
  995.     public function removeCart(Cart $cart): self
  996.     {
  997.         if ($this->carts->removeElement($cart)) {
  998.             // set the owning side to null (unless already changed)
  999.             if ($cart->getUser() === $this) {
  1000.                 $cart->setUser(null);
  1001.             }
  1002.         }
  1004.         return $this;
  1005.     }
  1007.     /**
  1008.      * @return Collection<int, Stockpharmacie>
  1009.      */
  1010.     public function getStockpharmacies(): Collection
  1011.     {
  1012.         return $this->stockpharmacies;
  1013.     }
  1015.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  1016.     {
  1017.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  1018.             $this->stockpharmacies[] = $stockpharmacy;
  1019.             $stockpharmacy->setUser($this);
  1020.         }
  1022.         return $this;
  1023.     }
  1025.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  1026.     {
  1027.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  1028.             // set the owning side to null (unless already changed)
  1029.             if ($stockpharmacy->getUser() === $this) {
  1030.                 $stockpharmacy->setUser(null);
  1031.             }
  1032.         }
  1034.         return $this;
  1035.     }
  1037.     /**
  1038.      * @return Collection<int, HistoriqueRefusProposition>
  1039.      */
  1040.     public function getHistoriqueRefusPropositions(): Collection
  1041.     {
  1042.         return $this->historiqueRefusPropositions;
  1043.     }
  1045.     public function addHistoriqueRefusProposition(HistoriqueRefusProposition $historiqueRefusProposition): self
  1046.     {
  1047.         if (!$this->historiqueRefusPropositions->contains($historiqueRefusProposition)) {
  1048.             $this->historiqueRefusPropositions[] = $historiqueRefusProposition;
  1049.             $historiqueRefusProposition->setPharmcie($this);
  1050.         }
  1052.         return $this;
  1053.     }
  1055.     public function removeHistoriqueRefusProposition(HistoriqueRefusProposition $historiqueRefusProposition): self
  1056.     {
  1057.         if ($this->historiqueRefusPropositions->removeElement($historiqueRefusProposition)) {
  1058.             // set the owning side to null (unless already changed)
  1059.             if ($historiqueRefusProposition->getPharmcie() === $this) {
  1060.                 $historiqueRefusProposition->setPharmcie(null);
  1061.             }
  1062.         }
  1064.         return $this;
  1065.     }
  1067.     public function getPayslocalisation(): ?Pays
  1068.     {
  1069.         return $this->payslocalisation;
  1070.     }
  1072.     public function setPayslocalisation(?Pays $payslocalisation): self
  1073.     {
  1074.         $this->payslocalisation = $payslocalisation;
  1076.         return $this;
  1077.     }
  1079.     public function getUrlexcelcmd(): ?string
  1080.     {
  1081.         return $this->urlexcelcmd;
  1082.     }
  1084.     public function setUrlexcelcmd(?string $urlexcelcmd): self
  1085.     {
  1086.         $this->urlexcelcmd = $urlexcelcmd;
  1088.         return $this;
  1089.     }
  1091.     public function getIsPaid(): ?bool
  1092.     {
  1093.         return $this->isPaid;
  1094.     }
  1096.     public function setIsPaid(?bool $isPaid): self
  1097.     {
  1098.         $this->isPaid = $isPaid;
  1100.         return $this;
  1101.     }
  1103.     /**
  1104.      * @return Collection<int, Discution>
  1105.      */
  1106.     public function getDiscutions(): Collection
  1107.     {
  1108.         return $this->discutions;
  1109.     }
  1111.     public function addDiscution(Discution $discution): self
  1112.     {
  1113.         if (!$this->discutions->contains($discution)) {
  1114.             $this->discutions[] = $discution;
  1115.             $discution->setUser($this);
  1116.         }
  1118.         return $this;
  1119.     }
  1121.     public function removeDiscution(Discution $discution): self
  1122.     {
  1123.         if ($this->discutions->removeElement($discution)) {
  1124.             // set the owning side to null (unless already changed)
  1125.             if ($discution->getUser() === $this) {
  1126.                 $discution->setUser(null);
  1127.             }
  1128.         }
  1130.         return $this;
  1131.     }
  1133.     /**
  1134.      * @return Collection<int, Reclamation>
  1135.      */
  1136.     public function getReclamations(): Collection
  1137.     {
  1138.         return $this->reclamations;
  1139.     }
  1141.     public function addReclamation(Reclamation $reclamation): self
  1142.     {
  1143.         if (!$this->reclamations->contains($reclamation)) {
  1144.             $this->reclamations[] = $reclamation;
  1145.             $reclamation->setUser($this);
  1146.         }
  1148.         return $this;
  1149.     }
  1151.     public function removeReclamation(Reclamation $reclamation): self
  1152.     {
  1153.         if ($this->reclamations->removeElement($reclamation)) {
  1154.             // set the owning side to null (unless already changed)
  1155.             if ($reclamation->getUser() === $this) {
  1156.                 $reclamation->setUser(null);
  1157.             }
  1158.         }
  1160.         return $this;
  1161.     }
  1163.     public function getImage(): ?string
  1164.     {
  1165.         return $this->image;
  1166.     }
  1168.     public function setImage(?string $image): self
  1169.     {
  1170.         $this->image = $image;
  1172.         return $this;
  1173.     }
  1175.     public function getUpdatedAt(): ?\DateTimeInterface
  1176.     {
  1177.         return $this->updatedAt;
  1178.     }
  1180.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  1181.     {
  1182.         $this->updatedAt = $updatedAt;
  1184.         return $this;
  1185.     }
  1187.     //pour l'upload image
  1188.     public function setImageFile(?File $imageFile = null): User
  1189.     {
  1190.         $this->imageFile = $imageFile;
  1191.         if ($imageFile instanceof UploadedFile) {
  1193.             $this->updatedAt = new \DateTime('now');
  1194.         }
  1196.         return $this;
  1197.     }
  1199.     public function getImageFile(): ?File
  1200.     {
  1201.         return $this->imageFile;
  1202.     }
  1204.     public function serialize()
  1205.     {
  1207.         return serialize(array(
  1208.             $this->id,
  1209.             $this->email,
  1210.             $this->password,
  1211.         ));
  1212.     }
  1214.     public function unserialize($serialized)
  1215.     {
  1217.         list(
  1218.             $this->id,
  1219.             $this->email,
  1220.             $this->password,
  1221.         ) = unserialize($serialized);
  1222.     }
  1224.     public function getVerificationCode(): ?string
  1225.     {
  1226.         return $this->verificationCode;
  1227.     }
  1229.     public function setVerificationCode(?string $verificationCode): self
  1230.     {
  1231.         $this->verificationCode = $verificationCode;
  1233.         return $this;
  1234.     }
  1236.     public function getVerified(): ?int
  1237.     {
  1238.         return $this->verified;
  1239.     }
  1241.     public function setVerified(?int $verified): self
  1242.     {
  1243.         $this->verified = $verified;
  1245.         return $this;
  1246.     }
  1248.     /**
  1249.      * @return Collection<int, Forecast>
  1250.      */
  1251.     public function getForecasts(): Collection
  1252.     {
  1253.         return $this->forecasts;
  1254.     }
  1256.     public function addForecast(Forecast $forecast): self
  1257.     {
  1258.         if (!$this->forecasts->contains($forecast)) {
  1259.             $this->forecasts[] = $forecast;
  1260.             $forecast->setUser($this);
  1261.         }
  1263.         return $this;
  1264.     }
  1266.     public function removeForecast(Forecast $forecast): self
  1267.     {
  1268.         if ($this->forecasts->removeElement($forecast)) {
  1269.             // set the owning side to null (unless already changed)
  1270.             if ($forecast->getUser() === $this) {
  1271.                 $forecast->setUser(null);
  1272.             }
  1273.         }
  1275.         return $this;
  1276.     }
  1278.     /**
  1279.      * @return Collection<int, UserTypepaiement>
  1280.      */
  1281.     public function getUserTypepaiements(): Collection
  1282.     {
  1283.         return $this->userTypepaiements;
  1284.     }
  1286.     public function addUserTypepaiement(UserTypepaiement $userTypepaiement): self
  1287.     {
  1288.         if (!$this->userTypepaiements->contains($userTypepaiement)) {
  1289.             $this->userTypepaiements[] = $userTypepaiement;
  1290.             $userTypepaiement->setUsers($this);
  1291.         }
  1293.         return $this;
  1294.     }
  1296.     public function removeUserTypepaiement(UserTypepaiement $userTypepaiement): self
  1297.     {
  1298.         if ($this->userTypepaiements->removeElement($userTypepaiement)) {
  1299.             // set the owning side to null (unless already changed)
  1300.             if ($userTypepaiement->getUsers() === $this) {
  1301.                 $userTypepaiement->setUsers(null);
  1302.             }
  1303.         }
  1305.         return $this;
  1306.     }
  1308.     public function getTypepaiements(): ?Typepaiement
  1309.     {
  1310.         return $this->typepaiements;
  1311.     }
  1313.     public function setTypepaiements(?Typepaiement $typepaiements): self
  1314.     {
  1315.         $this->typepaiements = $typepaiements;
  1317.         return $this;
  1318.     }
  1320.     /**
  1321.      * @return Collection<int, HistoriquePaiement>
  1322.      */
  1323.     public function getHistoriquePaiements(): Collection
  1324.     {
  1325.         return $this->historiquePaiements;
  1326.     }
  1328.     public function addHistoriquePaiement(HistoriquePaiement $historiquePaiement): self
  1329.     {
  1330.         if (!$this->historiquePaiements->contains($historiquePaiement)) {
  1331.             $this->historiquePaiements[] = $historiquePaiement;
  1332.             $historiquePaiement->setUser($this);
  1333.         }
  1335.         return $this;
  1336.     }
  1338.     public function removeHistoriquePaiement(HistoriquePaiement $historiquePaiement): self
  1339.     {
  1340.         if ($this->historiquePaiements->removeElement($historiquePaiement)) {
  1341.             // set the owning side to null (unless already changed)
  1342.             if ($historiquePaiement->getUser() === $this) {
  1343.                 $historiquePaiement->setUser(null);
  1344.             }
  1345.         }
  1347.         return $this;
  1348.     }
  1350.     /**
  1351.      * @return Collection<int, Forecast>
  1352.      */
  1353.     public function getInstancesForecasts(): Collection
  1354.     {
  1355.         return $this->instances_forecasts;
  1356.     }
  1358.     public function addInstancesForecast(Forecast $instancesForecast): self
  1359.     {
  1360.         if (!$this->instances_forecasts->contains($instancesForecast)) {
  1361.             $this->instances_forecasts[] = $instancesForecast;
  1362.             $instancesForecast->setGrossiste($this);
  1363.         }
  1365.         return $this;
  1366.     }
  1368.     public function removeInstancesForecast(Forecast $instancesForecast): self
  1369.     {
  1370.         if ($this->instances_forecasts->removeElement($instancesForecast)) {
  1371.             // set the owning side to null (unless already changed)
  1372.             if ($instancesForecast->getGrossiste() === $this) {
  1373.                 $instancesForecast->setGrossiste(null);
  1374.             }
  1375.         }
  1377.         return $this;
  1378.     }
  1380.     public function getIctusPharmacie(): ?IctusPharmacie
  1381.     {
  1382.         return $this->ictusPharmacie;
  1383.     }
  1385.     public function setIctusPharmacie(?IctusPharmacie $ictusPharmacie): self
  1386.     {
  1387.         $this->ictusPharmacie = $ictusPharmacie;
  1389.         return $this;
  1390.     }
  1392.     /**
  1393.      * @return Collection<int, IctusPanierPatient>
  1394.      */
  1395.     public function getIctusPanierPatients(): Collection
  1396.     {
  1397.         return $this->ictusPanierPatients;
  1398.     }
  1400.     public function addIctusPanierPatient(IctusPanierPatient $ictusPanierPatient): self
  1401.     {
  1402.         if (!$this->ictusPanierPatients->contains($ictusPanierPatient)) {
  1403.             $this->ictusPanierPatients[] = $ictusPanierPatient;
  1404.             $ictusPanierPatient->setUser($this);
  1405.         }
  1407.         return $this;
  1408.     }
  1410.     public function removeIctusPanierPatient(IctusPanierPatient $ictusPanierPatient): self
  1411.     {
  1412.         if ($this->ictusPanierPatients->removeElement($ictusPanierPatient)) {
  1413.             // set the owning side to null (unless already changed)
  1414.             if ($ictusPanierPatient->getUser() === $this) {
  1415.                 $ictusPanierPatient->setUser(null);
  1416.             }
  1417.         }
  1419.         return $this;
  1420.     }
  1422.     /**
  1423.      * @return Collection<int, IctusCommande>
  1424.      */
  1425.     public function getIctusCommandes(): Collection
  1426.     {
  1427.         return $this->ictusCommandes;
  1428.     }
  1430.     public function addIctusCommande(IctusCommande $ictusCommande): self
  1431.     {
  1432.         if (!$this->ictusCommandes->contains($ictusCommande)) {
  1433.             $this->ictusCommandes[] = $ictusCommande;
  1434.             $ictusCommande->setUser($this);
  1435.         }
  1437.         return $this;
  1438.     }
  1440.     public function removeIctusCommande(IctusCommande $ictusCommande): self
  1441.     {
  1442.         if ($this->ictusCommandes->removeElement($ictusCommande)) {
  1443.             // set the owning side to null (unless already changed)
  1444.             if ($ictusCommande->getUser() === $this) {
  1445.                 $ictusCommande->setUser(null);
  1446.             }
  1447.         }
  1449.         return $this;
  1450.     }
  1452.     public function getLatitude(): ?float
  1453.     {
  1454.         return $this->latitude;
  1455.     }
  1457.     public function setLatitude(?float $latitude): self
  1458.     {
  1459.         $this->latitude = $latitude;
  1461.         return $this;
  1462.     }
  1464.     public function getLogitude(): ?float
  1465.     {
  1466.         return $this->logitude;
  1467.     }
  1469.     public function setLogitude(?float $logitude): self
  1470.     {
  1471.         $this->logitude = $logitude;
  1473.         return $this;
  1474.     }
  1476.     /**
  1477.      * @return Collection<int, IctoRemboursement>
  1478.      */
  1479.     public function getIctoRemboursements(): Collection
  1480.     {
  1481.         return $this->ictoRemboursements;
  1482.     }
  1484.     public function addIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  1485.     {
  1486.         if (!$this->ictoRemboursements->contains($ictoRemboursement)) {
  1487.             $this->ictoRemboursements[] = $ictoRemboursement;
  1488.             $ictoRemboursement->setPayeur($this);
  1489.         }
  1491.         return $this;
  1492.     }
  1494.     public function removeIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  1495.     {
  1496.         if ($this->ictoRemboursements->removeElement($ictoRemboursement)) {
  1497.             // set the owning side to null (unless already changed)
  1498.             if ($ictoRemboursement->getPayeur() === $this) {
  1499.                 $ictoRemboursement->setPayeur(null);
  1500.             }
  1501.         }
  1503.         return $this;
  1504.     }
  1506.     public function isCguaccepted(): ?\DateTimeInterface
  1507.     {
  1508.         return $this->cguaccepted;
  1509.     }
  1511.     public function setCguaccepted(?\DateTimeInterface $cguaccepted): self
  1512.     {
  1513.         $this->cguaccepted = $cguaccepted;
  1515.         return $this;
  1516.     }
  1518.     public function isIsAdmin(): ?bool
  1519.     {
  1520.         return $this->isAdmin;
  1521.     }
  1523.     public function setIsAdmin(?bool $isAdmin): self
  1524.     {
  1525.         $this->isAdmin = $isAdmin;
  1527.         return $this;
  1528.     }
  1530.     public function getCIN(): ?string
  1531.     {
  1532.         return $this->CIN;
  1533.     }
  1535.     public function setCIN(?string $CIN): self
  1536.     {
  1537.         $this->CIN = $CIN;
  1539.         return $this;
  1540.     }
  1542.     /**
  1543.      * @return Collection<int, Ordonnance>
  1544.      */
  1545.     public function getOrdonnances(): Collection
  1546.     {
  1547.         return $this->ordonnances;
  1548.     }
  1550.     public function addOrdonnance(Ordonnance $ordonnance): self
  1551.     {
  1552.         if (!$this->ordonnances->contains($ordonnance)) {
  1553.             $this->ordonnances[] = $ordonnance;
  1554.             $ordonnance->setPropriertaire($this);
  1555.         }
  1557.         return $this;
  1558.     }
  1560.     public function removeOrdonnance(Ordonnance $ordonnance): self
  1561.     {
  1562.         if ($this->ordonnances->removeElement($ordonnance)) {
  1563.             // set the owning side to null (unless already changed)
  1564.             if ($ordonnance->getPropriertaire() === $this) {
  1565.                 $ordonnance->setPropriertaire(null);
  1566.             }
  1567.         }
  1569.         return $this;
  1570.     }
  1572.     /**
  1573.      * @return Collection<int, Adresse>
  1574.      */
  1575.     public function getAdresses(): Collection
  1576.     {
  1577.         return $this->adresses;
  1578.     }
  1580.     public function addAdress(Adresse $adress): self
  1581.     {
  1582.         if (!$this->adresses->contains($adress)) {
  1583.             $this->adresses[] = $adress;
  1584.             $adress->setPatient($this);
  1585.         }
  1587.         return $this;
  1588.     }
  1590.     public function removeAdress(Adresse $adress): self
  1591.     {
  1592.         if ($this->adresses->removeElement($adress)) {
  1593.             // set the owning side to null (unless already changed)
  1594.             if ($adress->getPatient() === $this) {
  1595.                 $adress->setPatient(null);
  1596.             }
  1597.         }
  1599.         return $this;
  1600.     }
  1602.     public function getSocieteLivraison(): ?SocieteLivraison
  1603.     {
  1604.         return $this->societeLivraison;
  1605.     }
  1607.     public function setSocieteLivraison(?SocieteLivraison $societeLivraison): self
  1608.     {
  1609.         $this->societeLivraison = $societeLivraison;
  1610.     }
  1612.     /**
  1613.      * @return Collection<int, IctusPanierSpecial>
  1614.      */
  1615.     public function getIctusPanierSpecials(): Collection
  1616.     {
  1617.         return $this->ictusPanierSpecials;
  1618.     }
  1620.     public function addIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  1621.     {
  1622.         if (!$this->ictusPanierSpecials->contains($ictusPanierSpecial)) {
  1623.             $this->ictusPanierSpecials[] = $ictusPanierSpecial;
  1624.             $ictusPanierSpecial->setUser($this);
  1625.         }
  1627.         return $this;
  1628.     }
  1630.     public function getReinitmdp(): ?string
  1631.     {
  1632.         return $this->reinitmdp;
  1633.     }
  1635.     public function setReinitmdp(?string $reinitmdp): self
  1636.     {
  1637.         $this->reinitmdp = $reinitmdp;
  1638.         return $this;
  1639.     }
  1641.     public function getValidateCode(): ?string
  1642.     {
  1643.         return $this->validate_code;
  1644.     }
  1646.     public function setValidateCode(?string $validate_code): self
  1647.     {
  1648.         $this->validate_code = $validate_code;
  1649.         return $this;
  1650.     }
  1652.     public function removeIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  1653.     {
  1654.         if ($this->ictusPanierSpecials->removeElement($ictusPanierSpecial)) {
  1655.             // set the owning side to null (unless already changed)
  1656.             if ($ictusPanierSpecial->getUser() === $this) {
  1657.                 $ictusPanierSpecial->setUser(null);
  1658.             }
  1659.         }
  1661.         return $this;
  1662.     }
  1664.     /**
  1665.      * @return Collection<int, CommandeSpecial>
  1666.      */
  1667.     public function getCommandeSpecials(): Collection
  1668.     {
  1669.         return $this->commandeSpecials;
  1670.     }
  1672.     public function addCommandeSpecial(CommandeSpecial $commandeSpecial): self
  1673.     {
  1674.         if (!$this->commandeSpecials->contains($commandeSpecial)) {
  1675.             $this->commandeSpecials[] = $commandeSpecial;
  1676.             $commandeSpecial->setGrossiste($this);
  1677.         }
  1679.         return $this;
  1680.     }
  1682.     public function removeCommandeSpecial(CommandeSpecial $commandeSpecial): self
  1683.     {
  1684.         if ($this->commandeSpecials->removeElement($commandeSpecial)) {
  1685.             // set the owning side to null (unless already changed)
  1686.             if ($commandeSpecial->getGrossiste() === $this) {
  1687.                 $commandeSpecial->setGrossiste(null);
  1688.             }
  1689.         }
  1691.         return $this;
  1692.     }
  1694.     public function getExpiredreinitmdp(): ?\DateTimeInterface
  1695.     {
  1696.         return $this->expiredreinitmdp;
  1697.     }
  1699.     public function setExpiredreinitmdp(?\DateTimeInterface $expiredreinitmdp): self
  1700.     {
  1701.         $this->expiredreinitmdp = $expiredreinitmdp;
  1702.         return $this;
  1703.     }
  1705.     /**
  1706.      * @return Collection<int, CommandeSpecial>
  1707.      */
  1708.     public function getCommandeSpecialsIctus(): Collection
  1709.     {
  1710.         return $this->commandeSpecialsIctus;
  1711.     }
  1713.     public function addCommandeSpecialsIctu(CommandeSpecial $commandeSpecialsIctu): self
  1714.     {
  1715.         if (!$this->commandeSpecialsIctus->contains($commandeSpecialsIctu)) {
  1716.             $this->commandeSpecialsIctus[] = $commandeSpecialsIctu;
  1717.             $commandeSpecialsIctu->setUser($this);
  1718.         }
  1720.         return $this;
  1721.     }
  1723.     public function removeCommandeSpecialsIctu(CommandeSpecial $commandeSpecialsIctu): self
  1724.     {
  1725.         if ($this->commandeSpecialsIctus->removeElement($commandeSpecialsIctu)) {
  1726.             // set the owning side to null (unless already changed)
  1727.             if ($commandeSpecialsIctu->getUser() === $this) {
  1728.                 $commandeSpecialsIctu->setUser(null);
  1729.             }
  1730.         }
  1732.         return $this;
  1733.     }
  1735.     /**
  1736.      * @return Collection<int, NonDisponibilite>
  1737.      */
  1738.     public function getNonDisponibilites(): Collection
  1739.     {
  1740.         return $this->nonDisponibilites;
  1741.     }
  1743.     public function addNonDisponibilite(NonDisponibilite $nonDisponibilite): self
  1744.     {
  1745.         if (!$this->nonDisponibilites->contains($nonDisponibilite)) {
  1746.             $this->nonDisponibilites[] = $nonDisponibilite;
  1747.             $nonDisponibilite->setLivreur($this);
  1748.         }
  1749.     }
  1751.     /**
  1752.      * @return Collection<int, FacturePatient>
  1753.      */
  1754.     public function getFacturePatients(): Collection
  1755.     {
  1756.         return $this->facturePatients;
  1757.     }
  1759.     public function addFacturePatient(FacturePatient $facturePatient): self
  1760.     {
  1761.         if (!$this->facturePatients->contains($facturePatient)) {
  1762.             $this->facturePatients[] = $facturePatient;
  1763.             $facturePatient->setUser($this);
  1764.         }
  1766.         return $this;
  1767.     }
  1769.     public function removeNonDisponibilite(NonDisponibilite $nonDisponibilite): self
  1770.     {
  1771.         if ($this->nonDisponibilites->removeElement($nonDisponibilite)) {
  1772.             // set the owning side to null (unless already changed)
  1773.             if ($nonDisponibilite->getLivreur() === $this) {
  1774.                 $nonDisponibilite->setLivreur(null);
  1775.             }
  1776.         }
  1777.     }
  1779.     public function removeFacturePatient(FacturePatient $facturePatient): self
  1780.     {
  1781.         if ($this->facturePatients->removeElement($facturePatient)) {
  1782.             // set the owning side to null (unless already changed)
  1783.             if ($facturePatient->getUser() === $this) {
  1784.                 $facturePatient->setUser(null);
  1785.             }
  1786.         }
  1788.         return $this;
  1789.     }
  1791.     public  function getPanierTotal()
  1792.     {
  1793.         $total = 0;
  1794.         foreach ($this->getIctusPanierPatients() as $panier) {
  1795.             $total += $panier->getTotal();
  1796.         }
  1798.         return (int)$total;
  1799.     }
  1801.     public function getReferenceClientTP(): ?string
  1802.     {
  1803.         return $this->referenceClientTP;
  1804.     }
  1806.     public function setReferenceClientTP(?string $referenceClientTP): self
  1807.     {
  1808.         $this->referenceClientTP = $referenceClientTP;
  1810.         return $this;
  1811.     }
  1813.     public function getSocietename(): ?string
  1814.     {
  1815.         return $this->societename;
  1816.     }
  1818.     public function setSocietename(?string $societename): self
  1819.     {
  1820.         $this->societename = $societename;
  1822.         return $this;
  1823.     }
  1825.     public function getDatenaissance(): ?\DateTimeInterface
  1826.     {
  1827.         return $this->datenaissance;
  1828.     }
  1830.     public function setDatenaissance(?\DateTimeInterface $datenaissance): self
  1831.     {
  1832.         $this->datenaissance = $datenaissance;
  1834.         return $this;
  1835.     }
  1837.     /**
  1838.      * @return Collection<int, Livraison>
  1839.      */
  1840.     public function getLivraisons(): Collection
  1841.     {
  1842.         return $this->livraisons;
  1843.     }
  1845.     public function addLivraison(Livraison $livraison): self
  1846.     {
  1847.         if (!$this->livraisons->contains($livraison)) {
  1848.             $this->livraisons[] = $livraison;
  1849.             $livraison->setLivreur($this);
  1850.         }
  1852.         return $this;
  1853.     }
  1855.     public function removeLivraison(Livraison $livraison): self
  1856.     {
  1857.         if ($this->livraisons->removeElement($livraison)) {
  1858.             // set the owning side to null (unless already changed)
  1859.             if ($livraison->getLivreur() === $this) {
  1860.                 $livraison->setLivreur(null);
  1861.             }
  1862.         }
  1864.         return $this;
  1865.     }
  1867.     /**
  1868.      * @return Collection<int, IctusMobileAppareil>
  1869.      */
  1870.     public function getIctusMobileAppareils(): Collection
  1871.     {
  1872.         return $this->ictusMobileAppareils;
  1873.     }
  1875.     public function addIctusMobileAppareil(IctusMobileAppareil $ictusMobileAppareil): self
  1876.     {
  1877.         if (!$this->ictusMobileAppareils->contains($ictusMobileAppareil)) {
  1878.             $this->ictusMobileAppareils[] = $ictusMobileAppareil;
  1879.             $ictusMobileAppareil->setUser($this);
  1880.         }
  1882.         return $this;
  1883.     }
  1885.     public function removeIctusMobileAppareil(IctusMobileAppareil $ictusMobileAppareil): self
  1886.     {
  1887.         if ($this->ictusMobileAppareils->removeElement($ictusMobileAppareil)) {
  1888.             // set the owning side to null (unless already changed)
  1889.             if ($ictusMobileAppareil->getUser() === $this) {
  1890.                 $ictusMobileAppareil->setUser(null);
  1891.             }
  1892.         }
  1894.         return $this;
  1895.     }
  1897.     /**
  1898.      * @return Collection<int, Photo>
  1899.      */
  1900.     public function getPhotoscreate(): Collection
  1901.     {
  1902.         return $this->photoscreate;
  1903.     }
  1905.     public function addPhotoscreate(Photo $photoscreate): self
  1906.     {
  1907.         if (!$this->photoscreate->contains($photoscreate)) {
  1908.             $this->photoscreate[] = $photoscreate;
  1909.             $photoscreate->setCreator($this);
  1910.         }
  1912.         return $this;
  1913.     }
  1915.     public function removePhotoscreate(Photo $photoscreate): self
  1916.     {
  1917.         if ($this->photoscreate->removeElement($photoscreate)) {
  1918.             // set the owning side to null (unless already changed)
  1919.             if ($photoscreate->getCreator() === $this) {
  1920.                 $photoscreate->setCreator(null);
  1921.             }
  1922.         }
  1924.         return $this;
  1925.     }
  1927.     public function getRangphoto(): ?int
  1928.     {
  1929.         return $this->rangphoto;
  1930.     }
  1932.     public function setRangphoto(?int $rangphoto): self
  1933.     {
  1934.         $this->rangphoto = $rangphoto;
  1936.         return $this;
  1937.     }
  1939.     public function getServiceSopharmad(): ?string
  1940.     {
  1941.         return $this->serviceSopharmad;
  1942.     }
  1944.     public function setServiceSopharmad(?string $serviceSopharmad): self
  1945.     {
  1946.         $this->serviceSopharmad = $serviceSopharmad;
  1948.         return $this;
  1949.     }
  1951.     /**
  1952.      * @return Collection<int, IctoMouvement>
  1953.      */
  1954.     public function getIctoMouvements(): Collection
  1955.     {
  1956.         return $this->ictoMouvements;
  1957.     }
  1959.     public function addIctoMouvement(IctoMouvement $ictoMouvement): self
  1960.     {
  1961.         if (!$this->ictoMouvements->contains($ictoMouvement)) {
  1962.             $this->ictoMouvements[] = $ictoMouvement;
  1963.             $ictoMouvement->setUser($this);
  1964.         }
  1966.         return $this;
  1967.     }
  1969.     public function removeIctoMouvement(IctoMouvement $ictoMouvement): self
  1970.     {
  1971.         if ($this->ictoMouvements->removeElement($ictoMouvement)) {
  1972.             // set the owning side to null (unless already changed)
  1973.             if ($ictoMouvement->getUser() === $this) {
  1974.                 $ictoMouvement->setUser(null);
  1975.             }
  1976.         }
  1978.         return $this;
  1979.     }
  1981.     /**
  1982.      * @return Collection<int, Doublon>
  1983.      */
  1984.     public function getDoublons(): Collection
  1985.     {
  1986.         return $this->doublons;
  1987.     }
  1989.     public function addDoublon(Doublon $doublon): self
  1990.     {
  1991.         if (!$this->doublons->contains($doublon)) {
  1992.             $this->doublons[] = $doublon;
  1993.             $doublon->setUser($this);
  1994.         }
  1996.         return $this;
  1997.     }
  1999.     public function removeDoublon(Doublon $doublon): self
  2000.     {
  2001.         if ($this->doublons->removeElement($doublon)) {
  2002.             // set the owning side to null (unless already changed)
  2003.             if ($doublon->getUser() === $this) {
  2004.                 $doublon->setUser(null);
  2005.             }
  2006.         }
  2008.         return $this;
  2009.     }
  2011.     /**
  2012.      * @return Collection<int, Rate>
  2013.      */
  2014.     public function getRates(): Collection
  2015.     {
  2016.         return $this->rates;
  2017.     }
  2019.     public function addRate(Rate $rate): self
  2020.     {
  2021.         if (!$this->rates->contains($rate)) {
  2022.             $this->rates[] = $rate;
  2023.             $rate->setUser($this);
  2024.         }
  2026.         return $this;
  2027.     }
  2029.     public function removeRate(Rate $rate): self
  2030.     {
  2031.         if ($this->rates->removeElement($rate)) {
  2032.             // set the owning side to null (unless already changed)
  2033.             if ($rate->getUser() === $this) {
  2034.                 $rate->setUser(null);
  2035.             }
  2036.         }
  2038.         return $this;
  2039.     }
  2041.     /**
  2042.      * @return Collection<int, SearchHistory>
  2043.      */
  2044.     public function getSearchHistories(): Collection
  2045.     {
  2046.         return $this->searchHistories;
  2047.     }
  2049.     public function addSearchHistory(SearchHistory $searchHistory): self
  2050.     {
  2051.         if (!$this->searchHistories->contains($searchHistory)) {
  2052.             $this->searchHistories[] = $searchHistory;
  2053.             $searchHistory->setUser($this);
  2054.         }
  2056.         return $this;
  2057.     }
  2059.     public function removeSearchHistory(SearchHistory $searchHistory): self
  2060.     {
  2061.         if ($this->searchHistories->removeElement($searchHistory)) {
  2062.             // set the owning side to null (unless already changed)
  2063.             if ($searchHistory->getUser() === $this) {
  2064.                 $searchHistory->setUser(null);
  2065.             }
  2066.         }
  2068.         return $this;
  2069.     }
  2071.     public function getLastTypeLivraison(): ?IctusTypeLivraison
  2072.     {
  2073.         return $this->lastTypeLivraison;
  2074.     }
  2076.     public function setLastTypeLivraison(?IctusTypeLivraison $lastTypeLivraison): self
  2077.     {
  2078.         $this->lastTypeLivraison = $lastTypeLivraison;
  2080.         return $this;
  2081.     }
  2083.     public function getLastTypePaiement(): ?IctusTypePaiement
  2084.     {
  2085.         return $this->lastTypePaiement;
  2086.     }
  2088.     public function setLastTypePaiement(?IctusTypePaiement $lastTypePaiement): self
  2089.     {
  2090.         $this->lastTypePaiement = $lastTypePaiement;
  2092.         return $this;
  2093.     }
  2095.     /**
  2096.      * @return Collection<int, RemiseUserPharmacie>
  2097.      */
  2098.     public function getRemiseUserPharmacies(): Collection
  2099.     {
  2100.         return $this->remiseUserPharmacies;
  2101.     }
  2103.     public function addRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  2104.     {
  2105.         if (!$this->remiseUserPharmacies->contains($remiseUserPharmacy)) {
  2106.             $this->remiseUserPharmacies[] = $remiseUserPharmacy;
  2107.             $remiseUserPharmacy->setUser($this);
  2108.         }
  2110.         return $this;
  2111.     }
  2113.     public function removeRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  2114.     {
  2115.         if ($this->remiseUserPharmacies->removeElement($remiseUserPharmacy)) {
  2116.             // set the owning side to null (unless already changed)
  2117.             if ($remiseUserPharmacy->getUser() === $this) {
  2118.                 $remiseUserPharmacy->setUser(null);
  2119.             }
  2120.         }
  2121.     }
  2123.     public function getFcmToken(): ?string
  2124.     {
  2125.         return $this->fcm_token;
  2126.     }
  2128.     public function setFcmToken(?string $fcm_token): self
  2129.     {
  2130.         $this->fcm_token = $fcm_token;
  2132.         return $this;
  2133.     }
  2135.     public function isIsRemiseAuto(): ?bool
  2136.     {
  2137.         return $this->isRemiseAuto;
  2138.     }
  2140.     public function setIsRemiseAuto(?bool $isRemiseAuto): self
  2141.     {
  2142.         $this->isRemiseAuto = $isRemiseAuto;
  2144.         return $this;
  2145.     }
  2147.     /**
  2148.      * @return Collection<int, Parrainage>
  2149.      */
  2150.     public function getParrainages(): Collection
  2151.     {
  2152.         return $this->parrainages;
  2153.     }
  2155.     public function addParrainage(Parrainage $parrainage): self
  2156.     {
  2157.         if (!$this->parrainages->contains($parrainage)) {
  2158.             $this->parrainages[] = $parrainage;
  2159.             $parrainage->setUser($this);
  2160.         }
  2162.         return $this;
  2163.     }
  2165.     public function removeParrainage(Parrainage $parrainage): self
  2166.     {
  2167.         if ($this->parrainages->removeElement($parrainage)) {
  2168.             // set the owning side to null (unless already changed)
  2169.             if ($parrainage->getUser() === $this) {
  2170.                 $parrainage->setUser(null);
  2171.             }
  2172.         }
  2174.         return $this;
  2175.     }
  2177.     /**
  2178.      * @return Collection<int, Favorite>
  2179.      */
  2180.     public function getFavorites(): Collection
  2181.     {
  2182.         return $this->favorites;
  2183.     }
  2185.     public function addFavorite(Favorite $favorite): self
  2186.     {
  2187.         if (!$this->favorites->contains($favorite)) {
  2188.             $this->favorites[] = $favorite;
  2189.             $favorite->setUser($this);
  2190.         }
  2192.         return $this;
  2193.     }
  2195.     public function removeFavorite(Favorite $favorite): self
  2196.     {
  2197.         if ($this->favorites->removeElement($favorite)) {
  2198.             // set the owning side to null (unless already changed)
  2199.             if ($favorite->getUser() === $this) {
  2200.                 $favorite->setUser(null);
  2201.             }
  2202.         }
  2204.         return $this;
  2205.     }
  2207.     /**
  2208.      * @return Collection<int, Carte>
  2209.      */
  2210.     public function getCartes(): Collection
  2211.     {
  2212.         return $this->cartes;
  2213.     }
  2215.     public function addCarte(Carte $carte): self
  2216.     {
  2217.         if (!$this->cartes->contains($carte)) {
  2218.             $this->cartes[] = $carte;
  2219.             $carte->setUser($this);
  2220.         }
  2222.         return $this;
  2223.     }
  2225.     public function removeCarte(Carte $carte): self
  2226.     {
  2227.         if ($this->cartes->removeElement($carte)) {
  2228.             // set the owning side to null (unless already changed)
  2229.             if ($carte->getUser() === $this) {
  2230.                 $carte->setUser(null);
  2231.             }
  2232.         }
  2234.         return $this;
  2235.     }
  2237.     /**
  2238.      * @return Collection<int, CertCertificat>
  2239.      */
  2240.     public function getCertCertificats(): Collection
  2241.     {
  2242.         return $this->certCertificats;
  2243.     }
  2245.     public function addCertCertificat(CertCertificat $certCertificat): self
  2246.     {
  2247.         if (!$this->certCertificats->contains($certCertificat)) {
  2248.             $this->certCertificats[] = $certCertificat;
  2249.             $certCertificat->setUser($this);
  2250.         }
  2252.         return $this;
  2253.     }
  2255.     public function removeCertCertificat(CertCertificat $certCertificat): self
  2256.     {
  2257.         if ($this->certCertificats->removeElement($certCertificat)) {
  2258.             // set the owning side to null (unless already changed)
  2259.             if ($certCertificat->getUser() === $this) {
  2260.                 $certCertificat->setUser(null);
  2261.             }
  2262.         }
  2264.         return $this;
  2265.     }
  2267.     public function isSexe(): ?int
  2268.     {
  2269.         return $this->sexe;
  2270.     }
  2272.     public function setSexe(?bool $sexe): self
  2273.     {
  2274.         $this->sexe = $sexe;
  2276.         return $this;
  2277.     }
  2279.     public function getCodeParrainageOther(): ?string
  2280.     {
  2281.         return $this->codeParrainageOther;
  2282.     }
  2284.     public function setCodeParrainageOther(?string $codeParrainageOther): self
  2285.     {
  2286.         $this->codeParrainageOther = $codeParrainageOther;
  2288.         return $this;
  2289.     }
  2291.     public function getCodeParrainageMine(): ?string
  2292.     {
  2293.         return $this->codeParrainageMine;
  2294.     }
  2296.     public function setCodeParrainageMine(?string $codeParrainageMine): self
  2297.     {
  2298.         $this->codeParrainageMine = $codeParrainageMine;
  2300.         return $this;
  2301.     }
  2303.     public function getFullAdresse(): ?string
  2304.     {
  2305.         return $this->getAddress() . ", " . $this->getQuartier()->getName() . ", " . $this->getQuartier()->getVille()->getName();
  2306.     }
  2308.     public function getPrefixNumber(): ?string
  2309.     {
  2310.         return $this->prefixNumber;
  2311.     }
  2313.     public function setPrefixNumber(?string $prefixNumber): self
  2314.     {
  2315.         $this->prefixNumber = $prefixNumber;
  2317.         return $this;
  2318.     }
  2320.     public function isIsDisponible(): ?bool
  2321.     {
  2322.         return $this->isDisponible;
  2323.     }
  2325.     public function setIsDisponible(?bool $isDisponible): self
  2326.     {
  2327.         $this->isDisponible = $isDisponible;
  2329.         return $this;
  2330.     }
  2331. }