src/Entity/User.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Validator\Constraints\Cascade;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. class User implements UserInterface, PasswordAuthenticatedUserInterface
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column(type: 'integer')]
  20.     private $id;
  22.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  23.     private $email;
  25.     #[ORM\Column(type: 'json')]
  26.     private $roles = [];
  28.     #[ORM\Column(type: 'string', nullable: true)]
  29.     private $password;
  31.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  32.     private $lastname;
  34.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  35.     private $firstname;
  37.     #[ORM\Column(type: 'boolean')]
  38.     private $is_active;
  40.     #[ORM\Column(type: 'boolean')]
  41.     private $is_optin;
  43.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.     private $token = null;
  46.     #[ORM\Column(type: 'datetime_immutable')]
  47.     private $created_at;
  49.     #[ORM\Column(type: 'boolean')]
  50.     private $is_dark_mode;
  52.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLog::class)]
  53.     private $userLogs;
  55.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  56.     private $telephone;
  58.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.     private $adeli;
  61.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  62.     private $adresse;
  64.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  65.     private $complementAdresse;
  67.     #[ORM\Column(type: 'string', nullable: true)]
  68.     private $zip;
  70.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  71.     private $ville;
  73.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  74.     private $siret;
  76.     #[ORM\Column(type: 'array', nullable: true)]
  77.     private $asso;
  79.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  80.     private $diplome;
  82.     #[ORM\Column(type: 'array', nullable: true)]
  83.     private $specialite = [];
  85.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  86.     private $anneeDiplome;
  88.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  89.     private $statuts;
  91.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  92.     private $asso_autre;
  94.     #[ORM\Column(type: 'date', nullable: true)]
  95.     private $naissance;
  97.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Abonnement::class)]
  98.     private $abonnements;
  100.     #[ORM\ManyToMany(targetEntity: Praticien::class, inversedBy: 'users')]
  101.     private $Praticiens;
  103.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Subscription::class)]
  104.     private Collection $subscriptions;
  106.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  107.     private ?string $registerToken = null;
  109.     #[ORM\Column(length: 255, nullable: true)]
  110.     private ?string $profil = null;
  112.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  113.     private ?string $data = null;
  115.     #[ORM\ManyToMany(targetEntity: Prescription::class, inversedBy: 'users')]
  116.     private Collection $prescriptions;
  118.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Consultation::class)]
  119.     private Collection $consultations;
  121.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'medecins')]
  122.     private ?self $medecin = null;
  124.     #[ORM\OneToMany(mappedBy: 'medecin', targetEntity: self::class)]
  125.     private Collection $medecins;
  127.     #[ORM\Column(length: 255, nullable: true)]
  128.     private ?string $diplome_copy = null;
  130.     #[ORM\Column(length: 255, nullable: true)]
  131.     private ?string $adeli_certif = null;
  133.     #[ORM\ManyToOne(inversedBy: 'users')]
  134.     private ?DataStatus $status = null;
  136.     #[ORM\Column(length: 255, nullable: true)]
  137.     private ?string $stripe_id = null;
  139.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  140.     private ?string $comment = null;
  142.     #[ORM\Column]
  143.     private ?bool $optinContact = null;
  145.     #[ORM\Column]
  146.     private ?bool $optinConsentement = null;
  148.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  149.     private ?\DateTimeInterface $optinConsentementDate = null;
  151.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Praticien::class)]
  152.     private Collection $praticiens;
  154.     #[ORM\Column(length: 255, nullable: true)]
  155.     private ?string $family = null;
  157.     #[ORM\Column(nullable: true)]
  158.     private ?bool $children = null;
  160.     #[ORM\Column(length: 255, nullable: true)]
  161.     private ?string $nb_child = null;
  163.     #[ORM\Column(length: 255, nullable: true)]
  164.     private ?string $job = null;
  166.     #[ORM\Column(length: 255, nullable: true)]
  167.     private ?string $job_detail = null;
  169.     #[ORM\Column(length: 255, nullable: true)]
  170.     private ?string $schedules = null;
  172.     #[ORM\Column(length: 255, nullable: true)]
  173.     private ?string $gender = null;
  175.     #[ORM\OneToMany(mappedBy: 'patient', targetEntity: DocumentPatient::class)]
  176.     private Collection $documents;
  178.     #[ORM\Column(nullable: true)]
  179.     private ?\DateTimeImmutable $deleteAccountAt = null;
  181.     #[ORM\Column(length: 255, nullable: true)]
  182.     private ?string $logo = null;
  184.     #[ORM\Column(length: 255, nullable: true)]
  185.     private ?string $country = null;
  187.     #[ORM\Column(length: 255, nullable: true)]
  188.     private ?string $office = null;
  190.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: QuestionnairePatient::class, cascade: ["persist", "remove"])]
  191.     private Collection $questionnairesPatient;
  193.     #[ORM\Column(length: 255, nullable: true)]
  194.     private ?string $specialite_autre = null;
  196.     #[ORM\OneToMany(mappedBy: 'patient', targetEntity: NoteHonoraire::class)]
  197.     private Collection $notesHonoraires;
  199.     #[ORM\Column(length: 255, nullable: true)]
  200.     private ?string $signature = null;
  202.     #[ORM\OneToMany(mappedBy: 'patient', targetEntity: DocumentSaved::class)]
  203.     private Collection $documentSaveds;
  205.     #[ORM\OneToMany(mappedBy: 'patient', targetEntity: DocumentUploaded::class)]
  206.     private Collection $documentUploadeds;
  208.     #[ORM\Column(length: 255, nullable: true)]
  209.     private ?string $website = null;
  211.     #[ORM\Column(length: 255, nullable: true)]
  212.     private ?string $price_number = null;
  214.     #[ORM\Column(length: 255, nullable: true)]
  215.     private ?string $price_letter = null;
  217.     #[ORM\Column(type: 'text', nullable: true)]
  218.     private ?string $notes = null;
  220.     #[ORM\Column(length: 255, nullable: true)]
  221.     private ?string $price_number_2 = null;
  223.     #[ORM\Column(length: 255, nullable: true)]
  224.     private ?string $price_letter_2 = null;
  226.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  227.     private ?string $notePraticien = null;
  229.     public function __construct()
  230.     {
  231.         $this->userLogs = new ArrayCollection();
  232.         $this->abonnements = new ArrayCollection();
  233.         $this->Praticiens = new ArrayCollection();
  234.         $this->subscriptions = new ArrayCollection();
  235.         $this->prescriptions = new ArrayCollection();
  236.         $this->consultations = new ArrayCollection();
  237.         $this->medecins = new ArrayCollection();
  238.         $this->praticiens = new ArrayCollection();
  239.         $this->documents = new ArrayCollection();
  240.         $this->questionnaires = new ArrayCollection();
  241.         $this->questionnairesPatient = new ArrayCollection();
  242.         $this->notesHonoraires = new ArrayCollection();
  243.         $this->documentSaveds = new ArrayCollection();
  244.         $this->documentUploadeds = new ArrayCollection();
  245.     }
  247.     public function getId(): ?int
  248.     {
  249.         return $this->id;
  250.     }
  252.     public function getEmail(): ?string
  253.     {
  254.         return $this->email;
  255.     }
  257.     public function setEmail(string $email): self
  258.     {
  259.         $this->email = $email;
  261.         return $this;
  262.     }
  264.     /**
  265.      * A visual identifier that represents this user.
  266.      *
  267.      * @see UserInterface
  268.      */
  269.     public function getUserIdentifier(): string
  270.     {
  271.         return (string) $this->email;
  272.     }
  274.     /**
  275.      * @see UserInterface
  276.      */
  277.     public function getRoles(): array
  278.     {
  279.         $roles = $this->roles;
  280.         // guarantee every user at least has ROLE_USER & ROLE_PATIENT
  281.         $roles[] = 'ROLE_USER';
  283.         return array_unique($roles);
  284.     }
  286.     public function setRoles(array $roles): self
  287.     {
  288.         $this->roles = $roles;
  290.         return $this;
  291.     }
  293.     /**
  294.      * @see PasswordAuthenticatedUserInterface
  295.      */
  296.     public function getPassword(): ?string
  297.     {
  298.         return $this->password;
  299.     }
  301.     public function setPassword(?string $password): self
  302.     {
  303.         $this->password = $password;
  305.         return $this;
  306.     }
  308.     /**
  309.      * @see UserInterface
  310.      */
  311.     public function eraseCredentials()
  312.     {
  313.         // If you store any temporary, sensitive data on the user, clear it here
  314.         // $this->plainPassword = null;
  315.     }
  317.     public function getLastname(): ?string
  318.     {
  319.         return $this->lastname;
  320.     }
  322.     public function setLastname(?string $lastname): self
  323.     {
  324.         $this->lastname = $lastname;
  326.         return $this;
  327.     }
  329.     public function getFirstname(): ?string
  330.     {
  331.         return $this->firstname;
  332.     }
  334.     public function setFirstname(?string $firstname): self
  335.     {
  336.         $this->firstname = $firstname;
  338.         return $this;
  339.     }
  341.     public function getIsActive(): ?bool
  342.     {
  343.         return $this->is_active;
  344.     }
  346.     public function setIsActive(bool $is_active): self
  347.     {
  348.         $this->is_active = $is_active;
  350.         return $this;
  351.     }
  353.     public function getIsOptin(): ?bool
  354.     {
  355.         return $this->is_optin;
  356.     }
  358.     public function setIsOptin(bool $is_optin): self
  359.     {
  360.         $this->is_optin = $is_optin;
  362.         return $this;
  363.     }
  365.     public function getToken(): ?string
  366.     {
  367.         return $this->token;
  368.     }
  370.     public function setToken(?string $token): self
  371.     {
  372.         $this->token = $token;
  374.         return $this;
  375.     }
  377.     public function getCreatedAt(): ?\DateTimeImmutable
  378.     {
  379.         return $this->created_at;
  380.     }
  382.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  383.     {
  384.         $this->created_at = $created_at;
  386.         return $this;
  387.     }
  389.     public function getIsDarkMode(): ?bool
  390.     {
  391.         return $this->is_dark_mode;
  392.     }
  394.     public function setIsDarkMode(bool $is_dark_mode): self
  395.     {
  396.         $this->is_dark_mode = $is_dark_mode;
  398.         return $this;
  399.     }
  401.     /**
  402.      * @return Collection<int, UserLog>
  403.      */
  404.     public function getUserLogs(): Collection
  405.     {
  406.         return $this->userLogs;
  407.     }
  409.     public function addUserLog(UserLog $userLog): self
  410.     {
  411.         if (!$this->userLogs->contains($userLog)) {
  412.             $this->userLogs[] = $userLog;
  413.             $userLog->setUser($this);
  414.         }
  416.         return $this;
  417.     }
  419.     public function removeUserLog(UserLog $userLog): self
  420.     {
  421.         if ($this->userLogs->removeElement($userLog)) {
  422.             // set the owning side to null (unless already changed)
  423.             if ($userLog->getUser() === $this) {
  424.                 $userLog->setUser(null);
  425.             }
  426.         }
  428.         return $this;
  429.     }
  431.     public function isIsActive(): ?bool
  432.     {
  433.         return $this->is_active;
  434.     }
  436.     public function isIsOptin(): ?bool
  437.     {
  438.         return $this->is_optin;
  439.     }
  441.     public function isIsDarkMode(): ?bool
  442.     {
  443.         return $this->is_dark_mode;
  444.     }
  446.     public function getTelephone(): ?string
  447.     {
  448.         return $this->telephone;
  449.     }
  451.     public function setTelephone(?string $telephone): self
  452.     {
  453.         $this->telephone = $telephone;
  455.         return $this;
  456.     }
  458.     public function getAdeli(): ?string
  459.     {
  460.         return $this->adeli;
  461.     }
  463.     public function setAdeli(string $adeli): self
  464.     {
  465.         $this->adeli = $adeli;
  467.         return $this;
  468.     }
  470.     public function getAdresse(): ?string
  471.     {
  472.         return $this->adresse;
  473.     }
  475.     public function setAdresse(?string $adresse): self
  476.     {
  477.         $this->adresse = $adresse;
  479.         return $this;
  480.     }
  482.     public function getComplementAdresse(): ?string
  483.     {
  484.         return $this->complementAdresse;
  485.     }
  487.     public function setComplementAdresse(?string $complementAdresse): self
  488.     {
  489.         $this->complementAdresse = $complementAdresse;
  491.         return $this;
  492.     }
  494.     public function getZip(): ?string
  495.     {
  496.         return $this->zip;
  497.     }
  499.     public function setZip(?string $zip): self
  500.     {
  501.         $this->zip = $zip;
  503.         return $this;
  504.     }
  506.     public function getVille(): ?string
  507.     {
  508.         return $this->ville;
  509.     }
  511.     public function setVille(?string $ville): self
  512.     {
  513.         $this->ville = $ville;
  515.         return $this;
  516.     }
  518.     public function getSiret(): ?string
  519.     {
  520.         return $this->siret;
  521.     }
  523.     public function setSiret(?string $siret): self
  524.     {
  525.         $this->siret = $siret;
  527.         return $this;
  528.     }
  530.     public function getAsso(): ?array
  531.     {
  532.         return $this->asso;
  533.     }
  535.     public function setAsso(?array $asso): self
  536.     {
  537.         $this->asso = $asso;
  539.         return $this;
  540.     }
  542.     public function getDiplome(): ?string
  543.     {
  544.         return $this->diplome;
  545.     }
  547.     public function setDiplome(?string $diplome): self
  548.     {
  549.         $this->diplome = $diplome;
  551.         return $this;
  552.     }
  554.     public function getSpecialite(): ?array
  555.     {
  556.         return $this->specialite;
  557.     }
  559.     public function setSpecialite(?array $specialite): self
  560.     {
  561.         $this->specialite = $specialite;
  563.         return $this;
  564.     }
  566.     public function getAnneeDiplome(): ?string
  567.     {
  568.         return $this->anneeDiplome;
  569.     }
  571.     public function setAnneeDiplome(?string $anneeDiplome): self
  572.     {
  573.         $this->anneeDiplome = $anneeDiplome;
  575.         return $this;
  576.     }
  578.     public function getStatuts(): ?string
  579.     {
  580.         return $this->statuts;
  581.     }
  583.     public function setStatuts(?string $statuts): self
  584.     {
  585.         $this->statuts = $statuts;
  587.         return $this;
  588.     }
  590.     public function getAssoAutre(): ?string
  591.     {
  592.         return $this->asso_autre;
  593.     }
  595.     public function setAssoAutre(?string $asso_autre): self
  596.     {
  597.         $this->asso_autre = $asso_autre;
  599.         return $this;
  600.     }
  602.     public function getNaissance(): ?\DateTimeInterface
  603.     {
  604.         return $this->naissance;
  605.     }
  607.     public function setNaissance(?\DateTimeInterface $naissance): self
  608.     {
  609.         $this->naissance = $naissance;
  611.         return $this;
  612.     }
  614.     /**
  615.      * @return Collection<int, Abonnement>
  616.      */
  617.     public function getAbonnements(): Collection
  618.     {
  619.         return $this->abonnements;
  620.     }
  622.     public function addAbonnement(Abonnement $abonnement): self
  623.     {
  624.         if (!$this->abonnements->contains($abonnement)) {
  625.             $this->abonnements[] = $abonnement;
  626.             $abonnement->setUser($this);
  627.         }
  629.         return $this;
  630.     }
  632.     public function removeAbonnement(Abonnement $abonnement): self
  633.     {
  634.         if ($this->abonnements->removeElement($abonnement)) {
  635.             // set the owning side to null (unless already changed)
  636.             if ($abonnement->getUser() === $this) {
  637.                 $abonnement->setUser(null);
  638.             }
  639.         }
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection<int, Subscription>
  646.      */
  647.     public function getSubscriptions(): Collection
  648.     {
  649.         return $this->subscriptions;
  650.     }
  652.     public function addSubscription(Subscription $subscription): static
  653.     {
  654.         if (!$this->subscriptions->contains($subscription)) {
  655.             $this->subscriptions->add($subscription);
  656.             $subscription->setUser($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeSubscription(Subscription $subscription): static
  663.     {
  664.         if ($this->subscriptions->removeElement($subscription)) {
  665.             // set the owning side to null (unless already changed)
  666.             if ($subscription->getUser() === $this) {
  667.                 $subscription->setUser(null);
  668.             }
  669.         }
  671.         return $this;
  672.     }
  674.     public function getRegisterToken(): ?string
  675.     {
  676.         return $this->registerToken;
  677.     }
  679.     public function setRegisterToken(?string $registerToken): static
  680.     {
  681.         $this->registerToken = $registerToken;
  683.         return $this;
  684.     }
  686.     public function getProfil(): ?string
  687.     {
  688.         return $this->profil;
  689.     }
  691.     public function setProfil(?string $profil): static
  692.     {
  693.         $this->profil = $profil;
  695.         return $this;
  696.     }
  698.     public function getData(): ?string
  699.     {
  700.         return $this->data;
  701.     }
  703.     public function setData(?string $data): static
  704.     {
  705.         $this->data = $data;
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, Prescription>
  712.      */
  713.     public function getPrescriptions(): Collection
  714.     {
  715.         return $this->prescriptions;
  716.     }
  718.     public function addPrescription(Prescription $prescription): static
  719.     {
  720.         if (!$this->prescriptions->contains($prescription)) {
  721.             $this->prescriptions->add($prescription);
  722.         }
  724.         return $this;
  725.     }
  727.     public function removePrescription(Prescription $prescription): static
  728.     {
  729.         $this->prescriptions->removeElement($prescription);
  731.         return $this;
  732.     }
  734.     /**
  735.      * @return Collection<int, Consultation>
  736.      */
  737.     public function getConsultations(): Collection
  738.     {
  739.         return $this->consultations;
  740.     }
  742.     public function addConsultation(Consultation $consultation): static
  743.     {
  744.         if (!$this->consultations->contains($consultation)) {
  745.             $this->consultations->add($consultation);
  746.             $consultation->setUser($this);
  747.         }
  749.         return $this;
  750.     }
  752.     public function removeConsultation(Consultation $consultation): static
  753.     {
  754.         if ($this->consultations->removeElement($consultation)) {
  755.             // set the owning side to null (unless already changed)
  756.             if ($consultation->getUser() === $this) {
  757.                 $consultation->setUser(null);
  758.             }
  759.         }
  761.         return $this;
  762.     }
  764.     public function getMedecin(): ?self
  765.     {
  766.         return $this->medecin;
  767.     }
  769.     public function setMedecin(?self $medecin): static
  770.     {
  771.         $this->medecin = $medecin;
  773.         return $this;
  774.     }
  776.     /**
  777.      * @return Collection<int, self>
  778.      */
  779.     public function getMedecins(): Collection
  780.     {
  781.         return $this->medecins;
  782.     }
  784.     public function addMedecin(self $medecin): static
  785.     {
  786.         if (!$this->medecins->contains($medecin)) {
  787.             $this->medecins->add($medecin);
  788.             $medecin->setMedecin($this);
  789.         }
  791.         return $this;
  792.     }
  794.     public function removeMedecin(self $medecin): static
  795.     {
  796.         if ($this->medecins->removeElement($medecin)) {
  797.             // set the owning side to null (unless already changed)
  798.             if ($medecin->getMedecin() === $this) {
  799.                 $medecin->setMedecin(null);
  800.             }
  801.         }
  803.         return $this;
  804.     }
  806.     public function getDiplomeCopy(): ?string
  807.     {
  808.         return $this->diplome_copy;
  809.     }
  811.     public function setDiplomeCopy(?string $diplome_copy): static
  812.     {
  813.         $this->diplome_copy = $diplome_copy;
  815.         return $this;
  816.     }
  818.     public function getAdeliCertif(): ?string
  819.     {
  820.         return $this->adeli_certif;
  821.     }
  823.     public function setAdeliCertif(?string $adeli_certif): static
  824.     {
  825.         $this->adeli_certif = $adeli_certif;
  827.         return $this;
  828.     }
  830.     public function getStatus(): ?DataStatus
  831.     {
  832.         return $this->status;
  833.     }
  835.     public function setStatus(?DataStatus $status): static
  836.     {
  837.         $this->status = $status;
  839.         return $this;
  840.     }
  842.     public function getStripeId(): ?string
  843.     {
  844.         return $this->stripe_id;
  845.     }
  847.     public function setStripeId(?string $stripe_id): static
  848.     {
  849.         $this->stripe_id = $stripe_id;
  851.         return $this;
  852.     }
  854.     public function getComment(): ?string
  855.     {
  856.         return $this->comment;
  857.     }
  859.     public function setComment(?string $comment): static
  860.     {
  861.         $this->comment = $comment;
  863.         return $this;
  864.     }
  866.     public function isOptinContact(): ?bool
  867.     {
  868.         return $this->optinContact;
  869.     }
  871.     public function setOptinContact(bool $optinContact): static
  872.     {
  873.         $this->optinContact = $optinContact;
  875.         return $this;
  876.     }
  878.     public function isOptinConsentement(): ?bool
  879.     {
  880.         return $this->optinConsentement;
  881.     }
  883.     public function setOptinConsentement(bool $optinConsentement): static
  884.     {
  885.         $this->optinConsentement = $optinConsentement;
  887.         return $this;
  888.     }
  890.     public function getOptinConsentementDate(): ?\DateTimeInterface
  891.     {
  892.         return $this->optinConsentementDate;
  893.     }
  895.     public function setOptinConsentementDate(?\DateTimeInterface $optinConsentementDate): static
  896.     {
  897.         $this->optinConsentementDate = $optinConsentementDate;
  899.         return $this;
  900.     }
  902.     /**
  903.      * @return Collection<int, Praticien>
  904.      */
  905.     public function getPraticiens(): Collection
  906.     {
  907.         return $this->praticiens;
  908.     }
  910.     public function addPraticien(Praticien $praticien): static
  911.     {
  912.         if (!$this->praticiens->contains($praticien)) {
  913.             $this->praticiens->add($praticien);
  914.             $praticien->setUser($this);
  915.         }
  917.         return $this;
  918.     }
  920.     public function removePraticien(Praticien $praticien): static
  921.     {
  922.         if ($this->praticiens->removeElement($praticien)) {
  923.             // set the owning side to null (unless already changed)
  924.             if ($praticien->getUser() === $this) {
  925.                 $praticien->setUser(null);
  926.             }
  927.         }
  929.         return $this;
  930.     }
  932.     public function getFamily(): ?string
  933.     {
  934.         return $this->family;
  935.     }
  937.     public function setFamily(?string $family): static
  938.     {
  939.         $this->family = $family;
  941.         return $this;
  942.     }
  944.     public function isChildren(): ?bool
  945.     {
  946.         return $this->children;
  947.     }
  949.     public function setChildren(?bool $children): static
  950.     {
  951.         $this->children = $children;
  953.         return $this;
  954.     }
  956.     public function getNbChild(): ?string
  957.     {
  958.         return $this->nb_child;
  959.     }
  961.     public function setNbChild(?string $nb_child): static
  962.     {
  963.         $this->nb_child = $nb_child;
  965.         return $this;
  966.     }
  968.     public function getJob(): ?string
  969.     {
  970.         return $this->job;
  971.     }
  973.     public function setJob(?string $job): static
  974.     {
  975.         $this->job = $job;
  977.         return $this;
  978.     }
  980.     public function getJobDetail(): ?string
  981.     {
  982.         return $this->job_detail;
  983.     }
  985.     public function setJobDetail(?string $job_detail): static
  986.     {
  987.         $this->job_detail = $job_detail;
  989.         return $this;
  990.     }
  992.     public function getSchedules(): ?string
  993.     {
  994.         return $this->schedules;
  995.     }
  997.     public function setSchedules(?string $schedules): static
  998.     {
  999.         $this->schedules = $schedules;
  1001.         return $this;
  1002.     }
  1004.     public function getGender(): ?string
  1005.     {
  1006.         return $this->gender;
  1007.     }
  1009.     public function setGender(?string $gender): static
  1010.     {
  1011.         $this->gender = $gender;
  1013.         return $this;
  1014.     }
  1016.     /**
  1017.      * @return Collection<int, DocumentPatient>
  1018.      */
  1019.     public function getDocuments(): Collection
  1020.     {
  1021.         return $this->documents;
  1022.     }
  1024.     public function addDocument(DocumentPatient $document): static
  1025.     {
  1026.         if (!$this->documents->contains($document)) {
  1027.             $this->documents->add($document);
  1028.             $document->setPatient($this);
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function removeDocument(DocumentPatient $document): static
  1035.     {
  1036.         if ($this->documents->removeElement($document)) {
  1037.             // set the owning side to null (unless already changed)
  1038.             if ($document->getPatient() === $this) {
  1039.                 $document->setPatient(null);
  1040.             }
  1041.         }
  1043.         return $this;
  1044.     }
  1046.     public function getDeleteAccountAt(): ?\DateTimeImmutable
  1047.     {
  1048.         return $this->deleteAccountAt;
  1049.     }
  1051.     public function setDeleteAccountAt(?\DateTimeImmutable $deleteAccountAt): static
  1052.     {
  1053.         $this->deleteAccountAt = $deleteAccountAt;
  1055.         return $this;
  1056.     }
  1058.     public function getLogo(): ?string
  1059.     {
  1060.         return $this->logo;
  1061.     }
  1063.     public function setLogo(?string $logo): static
  1064.     {
  1065.         $this->logo = $logo;
  1067.         return $this;
  1068.     }
  1070.     public function getCountry(): ?string
  1071.     {
  1072.         return $this->country;
  1073.     }
  1075.     public function setCountry(?string $country): static
  1076.     {
  1077.         $this->country = $country;
  1079.         return $this;
  1080.     }
  1082.     public function getOffice(): ?string
  1083.     {
  1084.         return $this->office;
  1085.     }
  1087.     public function setOffice(?string $office): static
  1088.     {
  1089.         $this->office = $office;
  1091.         return $this;
  1092.     }
  1095.     /**
  1096.      * @return Collection<int, QuestionnairePatient>
  1097.      */
  1098.     public function getQuestionnairesPatient(): Collection
  1099.     {
  1100.         return $this->questionnairesPatient;
  1101.     }
  1103.     public function addQuestionnairesPatient(QuestionnairePatient $questionnairesPatient): static
  1104.     {
  1105.         if (!$this->questionnairesPatient->contains($questionnairesPatient)) {
  1106.             $this->questionnairesPatient->add($questionnairesPatient);
  1107.             $questionnairesPatient->setUser($this);
  1108.         }
  1110.         return $this;
  1111.     }
  1113.     public function removeQuestionnairesPatient(QuestionnairePatient $questionnairesPatient): static
  1114.     {
  1115.         if ($this->questionnairesPatient->removeElement($questionnairesPatient)) {
  1116.             // set the owning side to null (unless already changed)
  1117.             if ($questionnairesPatient->getUser() === $this) {
  1118.                 $questionnairesPatient->setUser(null);
  1119.             }
  1120.         }
  1122.         return $this;
  1123.     }
  1125.     public function getSpecialiteAutre(): ?string
  1126.     {
  1127.         return $this->specialite_autre;
  1128.     }
  1130.     public function setSpecialiteAutre(?string $specialite_autre): static
  1131.     {
  1132.         $this->specialite_autre = $specialite_autre;
  1134.         return $this;
  1135.     }
  1137.     /**
  1138.      * @return Collection<int, NoteHonoraire>
  1139.      */
  1140.     public function getNotesHonoraires(): Collection
  1141.     {
  1142.         return $this->notesHonoraires;
  1143.     }
  1145.     public function addNotesHonoraire(NoteHonoraire $notesHonoraire): static
  1146.     {
  1147.         if (!$this->notesHonoraires->contains($notesHonoraire)) {
  1148.             $this->notesHonoraires->add($notesHonoraire);
  1149.             $notesHonoraire->setPatient($this);
  1150.         }
  1152.         return $this;
  1153.     }
  1155.     public function removeNotesHonoraire(NoteHonoraire $notesHonoraire): static
  1156.     {
  1157.         if ($this->notesHonoraires->removeElement($notesHonoraire)) {
  1158.             // set the owning side to null (unless already changed)
  1159.             if ($notesHonoraire->getPatient() === $this) {
  1160.                 $notesHonoraire->setPatient(null);
  1161.             }
  1162.         }
  1164.         return $this;
  1165.     }
  1167.     public function getSignature(): ?string
  1168.     {
  1169.         return $this->signature;
  1170.     }
  1172.     public function setSignature(?string $signature): static
  1173.     {
  1174.         $this->signature = $signature;
  1176.         return $this;
  1177.     }
  1179.     /**
  1180.      * @return Collection<int, DocumentSaved>
  1181.      */
  1182.     public function getDocumentSaveds(): Collection
  1183.     {
  1184.         return $this->documentSaveds;
  1185.     }
  1187.     public function addDocumentSaved(DocumentSaved $documentSaved): static
  1188.     {
  1189.         if (!$this->documentSaveds->contains($documentSaved)) {
  1190.             $this->documentSaveds->add($documentSaved);
  1191.             $documentSaved->setPatient($this);
  1192.         }
  1194.         return $this;
  1195.     }
  1197.     public function removeDocumentSaved(DocumentSaved $documentSaved): static
  1198.     {
  1199.         if ($this->documentSaveds->removeElement($documentSaved)) {
  1200.             // set the owning side to null (unless already changed)
  1201.             if ($documentSaved->getPatient() === $this) {
  1202.                 $documentSaved->setPatient(null);
  1203.             }
  1204.         }
  1206.         return $this;
  1207.     }
  1209.     /**
  1210.      * @return Collection<int, DocumentUploaded>
  1211.      */
  1212.     public function getDocumentUploadeds(): Collection
  1213.     {
  1214.         return $this->documentUploadeds;
  1215.     }
  1217.     public function addDocumentUploaded(DocumentUploaded $documentUploaded): static
  1218.     {
  1219.         if (!$this->documentUploadeds->contains($documentUploaded)) {
  1220.             $this->documentUploadeds->add($documentUploaded);
  1221.             $documentUploaded->setPatient($this);
  1222.         }
  1224.         return $this;
  1225.     }
  1227.     public function removeDocumentUploaded(DocumentUploaded $documentUploaded): static
  1228.     {
  1229.         if ($this->documentUploadeds->removeElement($documentUploaded)) {
  1230.             // set the owning side to null (unless already changed)
  1231.             if ($documentUploaded->getPatient() === $this) {
  1232.                 $documentUploaded->setPatient(null);
  1233.             }
  1234.         }
  1236.         return $this;
  1237.     }
  1239.     public function getWebsite(): ?string
  1240.     {
  1241.         return $this->website;
  1242.     }
  1244.     public function setWebsite(?string $website): static
  1245.     {
  1246.         $this->website = $website;
  1248.         return $this;
  1249.     }
  1251.     public function getPriceNumber(): ?string
  1252.     {
  1253.         return $this->price_number;
  1254.     }
  1256.     public function setPriceNumber(string $price_number): static
  1257.     {
  1258.         $this->price_number = $price_number;
  1260.         return $this;
  1261.     }
  1263.     public function getPriceLetter(): ?string
  1264.     {
  1265.         return $this->price_letter;
  1266.     }
  1268.     public function setPriceLetter(string $price_letter): static
  1269.     {
  1270.         $this->price_letter = $price_letter;
  1272.         return $this;
  1273.     }
  1275.     public function getNotes(): ?string
  1276.     {
  1277.         return $this->notes;
  1278.     }
  1280.     public function setNotes(?string $notes): static
  1281.     {
  1282.         $this->notes = $notes;
  1284.         return $this;
  1285.     }
  1287.     public function getPriceNumber2(): ?string
  1288.     {
  1289.         return $this->price_number_2;
  1290.     }
  1292.     public function setPriceNumber2(?string $price_number_2): static
  1293.     {
  1294.         $this->price_number_2 = $price_number_2;
  1296.         return $this;
  1297.     }
  1299.     public function getPriceLetter2(): ?string
  1300.     {
  1301.         return $this->price_letter_2;
  1302.     }
  1304.     public function setPriceLetter2(?string $price_letter_2): static
  1305.     {
  1306.         $this->price_letter_2 = $price_letter_2;
  1308.         return $this;
  1309.     }
  1311.     public function getNotePraticien(): ?string
  1312.     {
  1313.         return $this->notePraticien;
  1314.     }
  1316.     public function setNotePraticien(?string $notePraticien): static
  1317.     {
  1318.         $this->notePraticien = $notePraticien;
  1320.         return $this;
  1321.     }
  1323. // === DÉBUT MODIFICATION ROLES 2025-10-29 ===
  1325.     /**
  1326.      * Vérifie si l'utilisateur est un PRATICIEN
  1327.      * Note: CUSTOMER legacy est considéré comme PRATICIEN
  1328.      */
  1329.     public function isPraticien(): bool
  1330.     {
  1331.         return in_array('ROLE_PRATICIEN', $this->roles) ||
  1332.             (in_array('ROLE_CUSTOMER', $this->roles) &&
  1333.                 !in_array('ROLE_COACH', $this->roles) &&
  1334.                 !in_array('ROLE_PRATICIEN', $this->roles));
  1335.     }
  1337.     /**
  1338.      * Vérifie si l'utilisateur est un COACH
  1339.      */
  1340.     public function isCoach(): bool
  1341.     {
  1342.         return in_array('ROLE_COACH', $this->roles);
  1343.     }
  1345. // === FIN MODIFICATION ROLES ===
  1348. }