src/Entity/User.php line 21

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\ORM\Mapping as ORM;
  9. use Knp\DoctrineBehaviors\Contract\Entity\BlameableInterface;
  10. use Knp\DoctrineBehaviors\Model\Blameable\BlameableTrait;
  11. use Knp\DoctrineBehaviors\Contract\Entity\TimestampableInterface;
  12. use Knp\DoctrineBehaviors\Model\Timestampable\TimestampableTrait;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Validator\Constraints as Assert;
  18. #[ORM\Entity(repositoryClass: UserRepository::class)]
  19. #[ORM\Table(name: '`user`')]
  20. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  21. class User implements UserInterface, BlameableInterface, TimestampableInterface
  22. {
  23.     use BlameableTrait;
  24.     use TimestampableTrait;
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column(type: 'integer')]
  29.     private $id;
  31.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  32.     private $email;
  34.     #[ORM\Column(type: 'json')]
  35.     private $roles = [];
  37.     #[ORM\Column(type: 'string')]
  38.     #[Assert\Length(min: 8)]
  39.     #[Assert\Regex(
  40.         pattern: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{1,}$^',
  41.         message: 'Le mot de passe doit comporter au moins une lettre majuscule, une minuscule et un chiffre !',
  42.     )]
  43.     private $password;
  45.     #[ORM\Column(type: 'boolean')]
  46.     private $isVerified = false;
  48.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Demande::class)]
  49.     private $demandes;
  51.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  52.     private $nom;
  54.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  55.     private $prenom;
  57.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  58.     private $IntituleDuPoste;
  60.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  61.     private $Institution;
  63.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  64.     private $Resume;
  66.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  67.     private $Telephone;
  69.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  70.     private $Mobile;
  72.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  73.     private $NomUtilisateurGoogle;
  75.     #[ORM\Column(type: 'boolean', options:["default" => 0])]
  76.     private $Completed = 0;
  78.     #[ORM\Column(type: 'string', length: 1000, nullable: true)]
  79.     private $TokenReset;
  81.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  82.     private $nomOgranisme;
  84.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  85.     private $Adresse1;
  87.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  88.     private $Adresse2;
  90.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  91.     private $Adresse3;
  93.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  94.     private $Photo;
  96.     #[ORM\ManyToOne(targetEntity: Ville::class, inversedBy: 'users')]
  97.     private $Ville;
  99.     #[ORM\Column(type: 'integer', nullable: true)]
  100.     private $TelephoneOrganisme;
  102.     #[ORM\Column(type: 'integer', nullable: true)]
  103.     private $FaxOrganisme;
  105.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  106.     private $emailContact;
  108.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: FormUser::class)]
  109.     private $formUsers;
  111.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Reclamation::class)]
  112.     private $reclamations;
  114.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: ReclamationReponse::class)]
  115.     private $reclamationReponses;
  117.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: FormUserNote::class)]
  118.     private $formUserNotes;
  120.     #[ORM\ManyToMany(targetEntity: Demande::class, mappedBy: 'responsables')]
  121.     private $demandeResponsable;
  123.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: FormUserNote::class)]
  124.     private $demandeNotes;
  126.     #[ORM\ManyToMany(targetEntity: FormUser::class, mappedBy: 'Responsables')]
  127.     private $formUsersResponsable;
  129.     #[ORM\Column(type: 'boolean',  options:['default' => 1])]
  130.     private $Active = 1;
  132.     #[ORM\ManyToMany(targetEntity: Reclamation::class, mappedBy: 'responsables')]
  133.     private $reclamationsResponsable;
  135.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notification::class, orphanRemoval: true)]
  136.     private $notifications;
  138.     #[ORM\ManyToMany(targetEntity: Form::class, mappedBy: 'responsables')]
  139.     #[ORM\JoinTable(name: "form_responsable")]
  140.     private $formResponsables;
  142.     public function __construct()
  143.     {
  144.         $this->demandes = new ArrayCollection();
  145.         $this->formUsers = new ArrayCollection();
  146.         $this->reclamations = new ArrayCollection();
  147.         $this->reclamationReponses = new ArrayCollection();
  148.         $this->formUserNotes = new ArrayCollection();
  149.         $this->demandeResponsable = new ArrayCollection();
  150.         $this->demandeNotes = new ArrayCollection();
  151.         $this->formUsersResponsable = new ArrayCollection();
  152.         $this->reclamationsResponsable = new ArrayCollection();
  153.         $this->notifications = new ArrayCollection();
  154.         $this->formResponsables = new ArrayCollection();
  155.     }
  157.     public function getId(): ?int
  158.     {
  159.         return $this->id;
  160.     }
  162.     public function getEmail(): ?string
  163.     {
  164.         return $this->email;
  165.     }
  167.     public function setEmail(string $email): self
  168.     {
  169.         $this->email = $email;
  171.         return $this;
  172.     }
  174.     /**
  175.      * A visual identifier that represents this user.
  176.      *
  177.      * @see UserInterface
  178.      */
  179.     public function getUserIdentifier(): string
  180.     {
  181.         return (string) $this->email;
  182.     }
  184.     /**
  185.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  186.      */
  187.     public function getUsername(): string
  188.     {
  189.         return (string) $this->email;
  190.     }
  192.     /**
  193.      * @see UserInterface
  194.      */
  195.     public function getRoles(): array
  196.     {
  197.         $roles = $this->roles;
  198.         // guarantee every user at least has ROLE_USER
  199.         $roles[] = 'ROLE_USER';
  201.         return array_unique($roles);
  202.     }
  204.     public function setRoles(array $roles): self
  205.     {
  206.         $this->roles = $roles;
  208.         return $this;
  209.     }
  211.     /**
  212.      * @see PasswordAuthenticatedUserInterface
  213.      */
  214.     public function getPassword(): string
  215.     {
  216.         return $this->password;
  217.     }
  219.     public function setPassword(string $password): self
  220.     {
  221.         $this->password = $password;
  223.         return $this;
  224.     }
  226.     public function setAllRoles($roles): self
  227.     {
  228.         $this->setRoles([$roles]);
  229.         return $this;
  230.     }
  231.     public function getAllRoles(): string
  232.     {
  233.         return "";
  234.     }
  235.     /**
  236.      * Returning a salt is only needed, if you are not using a modern
  237.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  238.      *
  239.      * @see UserInterface
  240.      */
  241.     public function getSalt(): ?string
  242.     {
  243.         return null;
  244.     }
  246.     /**
  247.      * @see UserInterface
  248.      */
  249.     public function eraseCredentials()
  250.     {
  251.         // If you store any temporary, sensitive data on the user, clear it here
  252.         // $this->plainPassword = null;
  253.     }
  255.     public function isVerified(): bool
  256.     {
  257.         return $this->isVerified;
  258.     }
  260.     public function setIsVerified(bool $isVerified): self
  261.     {
  262.         $this->isVerified = $isVerified;
  264.         return $this;
  265.     }
  267.     /**
  268.      * @return Collection<int, Demande>
  269.      */
  270.     public function getDemandes(): Collection
  271.     {
  272.         return $this->demandes;
  273.     }
  275.     public function addDemande(Demande $demande): self
  276.     {
  277.         if (!$this->demandes->contains($demande)) {
  278.             $this->demandes[] = $demande;
  279.             $demande->setUser($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeDemande(Demande $demande): self
  286.     {
  287.         if ($this->demandes->removeElement($demande)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($demande->getUser() === $this) {
  290.                 $demande->setUser(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     public function getNom(): ?string
  298.     {
  299.         return $this->nom;
  300.     }
  302.     public function setNom(string $nom): self
  303.     {
  304.         $this->nom = $nom;
  306.         return $this;
  307.     }
  309.     public function getPrenom(): ?string
  310.     {
  311.         return $this->prenom;
  312.     }
  314.     public function setPrenom(string $prenom): self
  315.     {
  316.         $this->prenom = $prenom;
  318.         return $this;
  319.     }
  321.     public function getIntituleDuPoste(): ?string
  322.     {
  323.         return $this->IntituleDuPoste;
  324.     }
  326.     public function setIntituleDuPoste(string $IntituleDuPoste): self
  327.     {
  328.         $this->IntituleDuPoste = $IntituleDuPoste;
  330.         return $this;
  331.     }
  333.     public function getInstitution(): ?string
  334.     {
  335.         return $this->Institution;
  336.     }
  338.     public function setInstitution(string $Institution): self
  339.     {
  340.         $this->Institution = $Institution;
  342.         return $this;
  343.     }
  345.     public function getResume(): ?string
  346.     {
  347.         return $this->Resume;
  348.     }
  350.     public function setResume(?string $Resume): self
  351.     {
  352.         $this->Resume = $Resume;
  354.         return $this;
  355.     }
  357.     public function getTelephone(): ?string
  358.     {
  359.         return $this->Telephone;
  360.     }
  362.     public function setTelephone($Telephone): self
  363.     {
  364.         $this->Telephone = $Telephone;
  366.         return $this;
  367.     }
  369.     public function getMobile(): ?string
  370.     {
  371.         return $this->Mobile;
  372.     }
  374.     public function setMobile($Mobile): self
  375.     {
  376.         $this->Mobile = $Mobile;
  378.         return $this;
  379.     }
  381.     public function getNomUtilisateurGoogle(): ?string
  382.     {
  383.         return $this->NomUtilisateurGoogle;
  384.     }
  386.     public function setNomUtilisateurGoogle(?string $NomUtilisateurGoogle): self
  387.     {
  388.         $this->NomUtilisateurGoogle = $NomUtilisateurGoogle;
  390.         return $this;
  391.     }
  393.     public function getCompleted(): ?bool
  394.     {
  395.         return $this->Completed;
  396.     }
  398.     public function setCompleted(bool $Completed): self
  399.     {
  400.         $this->Completed = $Completed;
  402.         return $this;
  403.     }
  405.     public function getTokenReset(): ?string
  406.     {
  407.         return $this->TokenReset;
  408.     }
  410.     public function setTokenReset(?string $TokenReset): self
  411.     {
  412.         $this->TokenReset = $TokenReset;
  414.         return $this;
  415.     }
  417.     public function getNomOgranisme(): ?string
  418.     {
  419.         return $this->nomOgranisme;
  420.     }
  422.     public function setNomOgranisme(?string $nomOgranisme): self
  423.     {
  424.         $this->nomOgranisme = $nomOgranisme;
  426.         return $this;
  427.     }
  429.     public function getAdresse1(): ?string
  430.     {
  431.         return $this->Adresse1;
  432.     }
  434.     public function setAdresse1(?string $Adresse1): self
  435.     {
  436.         $this->Adresse1 = $Adresse1;
  438.         return $this;
  439.     }
  441.     public function getAdresse2(): ?string
  442.     {
  443.         return $this->Adresse2;
  444.     }
  446.     public function setAdresse2(string $Adresse2): self
  447.     {
  448.         $this->Adresse2 = $Adresse2;
  450.         return $this;
  451.     }
  453.     public function getAdresse3(): ?string
  454.     {
  455.         return $this->Adresse3;
  456.     }
  458.     public function setAdresse3(?string $Adresse3): self
  459.     {
  460.         $this->Adresse3 = $Adresse3;
  462.         return $this;
  463.     }
  465.     public function getPhoto(): ?string
  466.     {
  467.         return $this->Photo;
  468.     }
  470.     public function setPhoto(string $Photo): self
  471.     {
  472.         $this->Photo = $Photo;
  474.         return $this;
  475.     }
  477.     public function getVille(): ?Ville
  478.     {
  479.         return $this->Ville;
  480.     }
  482.     public function setVille(?Ville $Ville): self
  483.     {
  484.         $this->Ville = $Ville;
  486.         return $this;
  487.     }
  489.     public function getTelephoneOrganisme(): ?int
  490.     {
  491.         return $this->TelephoneOrganisme;
  492.     }
  494.     public function setTelephoneOrganisme($TelephoneOrganisme): self
  495.     {
  496.         $this->TelephoneOrganisme = $TelephoneOrganisme;
  498.         return $this;
  499.     }
  501.     public function getFaxOrganisme(): ?int
  502.     {
  503.         return $this->FaxOrganisme;
  504.     }
  506.     public function setFaxOrganisme($FaxOrganisme): self
  507.     {
  508.         $this->FaxOrganisme = $FaxOrganisme;
  510.         return $this;
  511.     }
  513.     public function getEmailContact(): ?string
  514.     {
  515.         return $this->emailContact;
  516.     }
  518.     public function setEmailContact(string $emailContact): self
  519.     {
  520.         $this->emailContact = $emailContact;
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, FormUser>
  527.      */
  528.     public function getFormUsers(): Collection
  529.     {
  530.         return $this->formUsers;
  531.     }
  533.     public function addFormUser(FormUser $formUser): self
  534.     {
  535.         if (!$this->formUsers->contains($formUser)) {
  536.             $this->formUsers[] = $formUser;
  537.             $formUser->setUser($this);
  538.         }
  540.         return $this;
  541.     }
  543.     public function removeFormUser(FormUser $formUser): self
  544.     {
  545.         if ($this->formUsers->removeElement($formUser)) {
  546.             // set the owning side to null (unless already changed)
  547.             if ($formUser->getUser() === $this) {
  548.                 $formUser->setUser(null);
  549.             }
  550.         }
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, Reclamation>
  557.      */
  558.     public function getReclamations(): Collection
  559.     {
  560.         return $this->reclamations;
  561.     }
  563.     public function addReclamation(Reclamation $reclamation): self
  564.     {
  565.         if (!$this->reclamations->contains($reclamation)) {
  566.             $this->reclamations[] = $reclamation;
  567.             $reclamation->setUser($this);
  568.         }
  570.         return $this;
  571.     }
  573.     public function removeReclamation(Reclamation $reclamation): self
  574.     {
  575.         if ($this->reclamations->removeElement($reclamation)) {
  576.             // set the owning side to null (unless already changed)
  577.             if ($reclamation->getUser() === $this) {
  578.                 $reclamation->setUser(null);
  579.             }
  580.         }
  582.         return $this;
  583.     }
  585.     /**
  586.      * @return Collection<int, ReclamationReponse>
  587.      */
  588.     public function getReclamationReponses(): Collection
  589.     {
  590.         return $this->reclamationReponses;
  591.     }
  593.     public function addReclamationReponse(ReclamationReponse $reclamationReponse): self
  594.     {
  595.         if (!$this->reclamationReponses->contains($reclamationReponse)) {
  596.             $this->reclamationReponses[] = $reclamationReponse;
  597.             $reclamationReponse->setUser($this);
  598.         }
  600.         return $this;
  601.     }
  603.     public function removeReclamationReponse(ReclamationReponse $reclamationReponse): self
  604.     {
  605.         if ($this->reclamationReponses->removeElement($reclamationReponse)) {
  606.             // set the owning side to null (unless already changed)
  607.             if ($reclamationReponse->getUser() === $this) {
  608.                 $reclamationReponse->setUser(null);
  609.             }
  610.         }
  612.         return $this;
  613.     }
  614.     public function getExportData()
  615.     {
  616.         return \array_merge([
  617.             'id' => $this->getId(),
  618.             'Nom' => $this->getNom(),
  619.             'Prénom' => $this->getPrenom(),
  620.             'Teléphone' => $this->getTelephoneOrganisme(),
  621.             'Mobile' => $this->getMobile() ?? '',
  622.             'Ville' => $this->getVille() ?? '',
  623.             'Email' => $this->getEmailContact() ?? '',
  624.             'Date de creation' => $this->getCreatedAt() ? $this->getCreatedAt()->format('Y-m-d') : '',
  625.             'Poste' => $this->getIntituleDuPoste() ?? '',
  626.             'Active' => $this->isActive() ?? '',
  627.         ]);
  628.     }
  630.     public function __toString()
  631.     {
  632.         return $this->getEmail();
  633.     }
  635.     /**
  636.      * @return Collection<int, FormUserNote>
  637.      */
  638.     public function getFormUserNotes(): Collection
  639.     {
  640.         return $this->formUserNotes;
  641.     }
  643.     public function addFormUserNote(FormUserNote $formUserNote): self
  644.     {
  645.         if (!$this->formUserNotes->contains($formUserNote)) {
  646.             $this->formUserNotes[] = $formUserNote;
  647.             $formUserNote->setUser($this);
  648.         }
  650.         return $this;
  651.     }
  653.     public function removeFormUserNote(FormUserNote $formUserNote): self
  654.     {
  655.         if ($this->formUserNotes->removeElement($formUserNote)) {
  656.             // set the owning side to null (unless already changed)
  657.             if ($formUserNote->getUser() === $this) {
  658.                 $formUserNote->setUser(null);
  659.             }
  660.         }
  662.         return $this;
  663.     }
  665.      /**
  666.      * @return Collection<int, DemandeNote>
  667.      */
  668.     public function getDemandeNotes(): Collection
  669.     {
  670.         return $this->demandeNotes;
  671.     }
  673.     public function addDemandeNote(DemandeNote $demandeNote): self
  674.     {
  675.         if (!$this->demandeNotes->contains($demandeNote)) {
  676.             $this->demandeNotes[] = $demandeNote;
  677.             $demandeNote->setUser($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeDemandeNote(DemandeNote $demandeNote): self
  684.     {
  685.         if ($this->demandeNotes->removeElement($demandeNote)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($demandeNote->getUser() === $this) {
  688.                 $demandeNote->setUser(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     /**
  696.      * @return Collection<int, Demande>
  697.      */
  698.     public function getDemandeResponsable(): Collection
  699.     {
  700.         return $this->demandeResponsable;
  701.     }
  703.     public function addDemandeResponsable(Demande $demandeResponsable): self
  704.     {
  705.         if (!$this->demandeResponsable->contains($demandeResponsable)) {
  706.             $this->demandeResponsable[] = $demandeResponsable;
  707.             $demandeResponsable->addResponsable($this);
  708.         }
  710.         return $this;
  711.     }
  713.     public function removeDemandeResponsable(Demande $demandeResponsable): self
  714.     {
  715.         if ($this->demandeResponsable->removeElement($demandeResponsable)) {
  716.             $demandeResponsable->removeResponsable($this);
  717.         }
  719.         return $this;
  720.     }
  722.     /**
  723.      * @return Collection<int, FormUser>
  724.      */
  725.     public function getFormUsersResponsable(): Collection
  726.     {
  727.         return $this->formUsersResponsable;
  728.     }
  730.     public function addFormUsersResponsable(FormUser $formUsersResponsable): self
  731.     {
  732.         if (!$this->formUsersResponsable->contains($formUsersResponsable)) {
  733.             $this->formUsersResponsable[] = $formUsersResponsable;
  734.             $formUsersResponsable->addResponsable($this);
  735.         }
  737.         return $this;
  738.     }
  740.     public function removeFormUsersResponsable(FormUser $formUsersResponsable): self
  741.     {
  742.         if ($this->formUsersResponsable->removeElement($formUsersResponsable)) {
  743.             $formUsersResponsable->removeResponsable($this);
  744.         }
  746.         return $this;
  747.     }
  749.     public function isActive(): ?bool
  750.     {
  751.         return $this->Active;
  752.     }
  754.     public function setActive(bool $Active): self
  755.     {
  756.         $this->Active = $Active;
  758.         return $this;
  759.     }
  761.     /**
  762.      * @return Collection<int, Reclamation>
  763.      */
  764.     public function getReclamationsResponsable(): Collection
  765.     {
  766.         return $this->reclamationsResponsable;
  767.     }
  769.     public function addReclamationsResponsable(Reclamation $reclamationsResponsable): self
  770.     {
  771.         if (!$this->reclamationsResponsable->contains($reclamationsResponsable)) {
  772.             $this->reclamationsResponsable[] = $reclamationsResponsable;
  773.             $reclamationsResponsable->addResponsable($this);
  774.         }
  776.         return $this;
  777.     }
  779.     public function removeReclamationsResponsable(Reclamation $reclamationsResponsable): self
  780.     {
  781.         if ($this->reclamationsResponsable->removeElement($reclamationsResponsable)) {
  782.             $reclamationsResponsable->removeResponsable($this);
  783.         }
  785.         return $this;
  786.     }
  788.     /**
  789.      * @return Collection<int, Notification>
  790.      */
  791.     public function getNotifications(): Collection
  792.     {
  793.         return $this->notifications;
  794.     }
  796.     public function addNotification(Notification $notification): self
  797.     {
  798.         if (!$this->notifications->contains($notification)) {
  799.             $this->notifications[] = $notification;
  800.             $notification->setUser($this);
  801.         }
  803.         return $this;
  804.     }
  806.     public function removeNotification(Notification $notification): self
  807.     {
  808.         if ($this->notifications->removeElement($notification)) {
  809.             // set the owning side to null (unless already changed)
  810.             if ($notification->getUser() === $this) {
  811.                 $notification->setUser(null);
  812.             }
  813.         }
  815.         return $this;
  816.     }
  818.     /**
  819.      * @return Collection<int, Form>
  820.      */
  821.     public function getFormResponsables(): Collection
  822.     {
  823.         return $this->formResponsables;
  824.     }
  826.     public function addFormResponsable(Form $formResponsable): self
  827.     {
  828.         if (!$this->formResponsables->contains($formResponsable)) {
  829.             $this->formResponsables[] = $formResponsable;
  830.             $formResponsable->addResponsable($this);
  831.         }
  833.         return $this;
  834.     }
  836.     public function removeFormResponsable(Form $formResponsable): self
  837.     {
  838.         if ($this->formResponsables->removeElement($formResponsable)) {
  839.             $formResponsable->removeResponsable($this);
  840.         }
  842.         return $this;
  843.     }
  844. }