src/Entity/User.php line 21

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\UserRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Knp\DoctrineBehaviors\Contract\Entity\BlameableInterface;
  8. use Knp\DoctrineBehaviors\Model\Blameable\BlameableTrait;
  9. use Knp\DoctrineBehaviors\Contract\Entity\TimestampableInterface;
  10. use Knp\DoctrineBehaviors\Model\Timestampable\TimestampableTrait;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Validator\Constraints as Assert;
  15. #[ORM\Entity(repositoryClassUserRepository::class)]
  16. #[ORM\Table(name'`user`')]
  17. #[UniqueEntity(fields: ['email'], message'There is already an account with this email')]
  18. class User implements UserInterfaceBlameableInterfaceTimestampableInterface
  19. {
  20.     use BlameableTrait;
  21.     use TimestampableTrait;
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column(type'integer')]
  25.     private $id;
  26.     #[ORM\Column(type'string'length180uniquetrue)]
  27.     private $email;
  28.     #[ORM\Column(type'json')]
  29.     private $roles = [];
  30.     #[ORM\Column(type'string')]
  31.     #[Assert\Length(min8)]
  32.     #[Assert\Regex(
  33.         pattern'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{1,}$^',
  34.         message'Le mot de passe doit comporter au moins une lettre majuscule, une minuscule et un chiffre !',
  35.     )]
  36.     private $password;
  37.     #[ORM\Column(type'boolean')]
  38.     private $isVerified false;
  39.     #[ORM\OneToMany(mappedBy'User'targetEntityDemande::class)]
  40.     private $demandes;
  41.     #[ORM\Column(type'string'length255nullabletrue)]
  42.     private $nom;
  43.     #[ORM\Column(type'string'length255nullabletrue)]
  44.     private $prenom;
  45.     #[ORM\Column(type'string'length255nullabletrue)]
  46.     private $IntituleDuPoste;
  47.     #[ORM\Column(type'string'length255nullabletrue)]
  48.     private $Institution;
  49.     #[ORM\Column(type'string'length255nullabletrue)]
  50.     private $Resume;
  51.     #[ORM\Column(type'string'length180nullabletrue)]
  52.     private $Telephone;
  53.     #[ORM\Column(type'string'length180nullabletrue)]
  54.     private $Mobile;
  55.     #[ORM\Column(type'string'length255nullabletrue)]
  56.     private $NomUtilisateurGoogle;
  57.     #[ORM\Column(type'boolean'options:["default" => 0])]
  58.     private $Completed 0;
  59.     #[ORM\Column(type'string'length1000nullabletrue)]
  60.     private $TokenReset;
  61.     #[ORM\Column(type'string'length255nullabletrue)]
  62.     private $nomOgranisme;
  63.     #[ORM\Column(type'string'length255nullabletrue)]
  64.     private $Adresse1;
  65.     #[ORM\Column(type'string'length255nullabletrue)]
  66.     private $Adresse2;
  67.     #[ORM\Column(type'string'length255nullabletrue)]
  68.     private $Adresse3;
  69.     #[ORM\Column(type'string'length255nullabletrue)]
  70.     private $Photo;
  71.     #[ORM\ManyToOne(targetEntityVille::class, inversedBy'users')]
  72.     private $Ville;
  73.     #[ORM\Column(type'integer'nullabletrue)]
  74.     private $TelephoneOrganisme;
  75.     #[ORM\Column(type'integer'nullabletrue)]
  76.     private $FaxOrganisme;
  77.     #[ORM\Column(type'string'length255nullabletrue)]
  78.     private $emailContact;
  79.     #[ORM\OneToMany(mappedBy'User'targetEntityFormUser::class)]
  80.     private $formUsers;
  81.     #[ORM\OneToMany(mappedBy'User'targetEntityReclamation::class)]
  82.     private $reclamations;
  83.     #[ORM\OneToMany(mappedBy'User'targetEntityReclamationReponse::class)]
  84.     private $reclamationReponses;
  85.     #[ORM\OneToMany(mappedBy'User'targetEntityFormUserNote::class)]
  86.     private $formUserNotes;
  87.     #[ORM\ManyToMany(targetEntityDemande::class, mappedBy'responsables')]
  88.     private $demandeResponsable;
  89.     #[ORM\OneToMany(mappedBy'user'targetEntityFormUserNote::class)]
  90.     private $demandeNotes;
  91.     #[ORM\ManyToMany(targetEntityFormUser::class, mappedBy'Responsables')]
  92.     private $formUsersResponsable;
  93.     #[ORM\Column(type'boolean',  options:['default' => 1])]
  94.     private $Active 1;
  95.     #[ORM\ManyToMany(targetEntityReclamation::class, mappedBy'responsables')]
  96.     private $reclamationsResponsable;
  97.     #[ORM\OneToMany(mappedBy'user'targetEntityNotification::class, orphanRemovaltrue)]
  98.     private $notifications;
  99.     #[ORM\ManyToMany(targetEntityForm::class, mappedBy'responsables')]
  100.     #[ORM\JoinTable(name"form_responsable")]
  101.     private $formResponsables;
  102.     public function __construct()
  103.     {
  104.         $this->demandes = new ArrayCollection();
  105.         $this->formUsers = new ArrayCollection();
  106.         $this->reclamations = new ArrayCollection();
  107.         $this->reclamationReponses = new ArrayCollection();
  108.         $this->formUserNotes = new ArrayCollection();
  109.         $this->demandeResponsable = new ArrayCollection();
  110.         $this->demandeNotes = new ArrayCollection();
  111.         $this->formUsersResponsable = new ArrayCollection();
  112.         $this->reclamationsResponsable = new ArrayCollection();
  113.         $this->notifications = new ArrayCollection();
  114.         $this->formResponsables = new ArrayCollection();
  115.     }
  116.     public function getId(): ?int
  117.     {
  118.         return $this->id;
  119.     }
  120.     public function getEmail(): ?string
  121.     {
  122.         return $this->email;
  123.     }
  124.     public function setEmail(string $email): self
  125.     {
  126.         $this->email $email;
  127.         return $this;
  128.     }
  129.     /**
  130.      * A visual identifier that represents this user.
  131.      *
  132.      * @see UserInterface
  133.      */
  134.     public function getUserIdentifier(): string
  135.     {
  136.         return (string) $this->email;
  137.     }
  138.     /**
  139.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  140.      */
  141.     public function getUsername(): string
  142.     {
  143.         return (string) $this->email;
  144.     }
  145.     /**
  146.      * @see UserInterface
  147.      */
  148.     public function getRoles(): array
  149.     {
  150.         $roles $this->roles;
  151.         // guarantee every user at least has ROLE_USER
  152.         $roles[] = 'ROLE_USER';
  153.         return array_unique($roles);
  154.     }
  155.     public function setRoles(array $roles): self
  156.     {
  157.         $this->roles $roles;
  158.         return $this;
  159.     }
  160.     /**
  161.      * @see PasswordAuthenticatedUserInterface
  162.      */
  163.     public function getPassword(): string
  164.     {
  165.         return $this->password;
  166.     }
  167.     public function setPassword(string $password): self
  168.     {
  169.         $this->password $password;
  170.         return $this;
  171.     }
  172.     public function setAllRoles($roles): self
  173.     {
  174.         $this->setRoles([$roles]);
  175.         return $this;
  176.     }
  177.     public function getAllRoles(): string
  178.     {
  179.         return "";
  180.     }
  181.     /**
  182.      * Returning a salt is only needed, if you are not using a modern
  183.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  184.      *
  185.      * @see UserInterface
  186.      */
  187.     public function getSalt(): ?string
  188.     {
  189.         return null;
  190.     }
  191.     /**
  192.      * @see UserInterface
  193.      */
  194.     public function eraseCredentials()
  195.     {
  196.         // If you store any temporary, sensitive data on the user, clear it here
  197.         // $this->plainPassword = null;
  198.     }
  199.     public function isVerified(): bool
  200.     {
  201.         return $this->isVerified;
  202.     }
  203.     public function setIsVerified(bool $isVerified): self
  204.     {
  205.         $this->isVerified $isVerified;
  206.         return $this;
  207.     }
  208.     /**
  209.      * @return Collection<int, Demande>
  210.      */
  211.     public function getDemandes(): Collection
  212.     {
  213.         return $this->demandes;
  214.     }
  215.     public function addDemande(Demande $demande): self
  216.     {
  217.         if (!$this->demandes->contains($demande)) {
  218.             $this->demandes[] = $demande;
  219.             $demande->setUser($this);
  220.         }
  221.         return $this;
  222.     }
  223.     public function removeDemande(Demande $demande): self
  224.     {
  225.         if ($this->demandes->removeElement($demande)) {
  226.             // set the owning side to null (unless already changed)
  227.             if ($demande->getUser() === $this) {
  228.                 $demande->setUser(null);
  229.             }
  230.         }
  231.         return $this;
  232.     }
  233.     public function getNom(): ?string
  234.     {
  235.         return $this->nom;
  236.     }
  237.     public function setNom(string $nom): self
  238.     {
  239.         $this->nom $nom;
  240.         return $this;
  241.     }
  242.     public function getPrenom(): ?string
  243.     {
  244.         return $this->prenom;
  245.     }
  246.     public function setPrenom(string $prenom): self
  247.     {
  248.         $this->prenom $prenom;
  249.         return $this;
  250.     }
  251.     public function getIntituleDuPoste(): ?string
  252.     {
  253.         return $this->IntituleDuPoste;
  254.     }
  255.     public function setIntituleDuPoste(string $IntituleDuPoste): self
  256.     {
  257.         $this->IntituleDuPoste $IntituleDuPoste;
  258.         return $this;
  259.     }
  260.     public function getInstitution(): ?string
  261.     {
  262.         return $this->Institution;
  263.     }
  264.     public function setInstitution(string $Institution): self
  265.     {
  266.         $this->Institution $Institution;
  267.         return $this;
  268.     }
  269.     public function getResume(): ?string
  270.     {
  271.         return $this->Resume;
  272.     }
  273.     public function setResume(?string $Resume): self
  274.     {
  275.         $this->Resume $Resume;
  276.         return $this;
  277.     }
  278.     public function getTelephone(): ?string
  279.     {
  280.         return $this->Telephone;
  281.     }
  282.     public function setTelephone($Telephone): self
  283.     {
  284.         $this->Telephone $Telephone;
  285.         return $this;
  286.     }
  287.     public function getMobile(): ?string
  288.     {
  289.         return $this->Mobile;
  290.     }
  291.     public function setMobile($Mobile): self
  292.     {
  293.         $this->Mobile $Mobile;
  294.         return $this;
  295.     }
  296.     public function getNomUtilisateurGoogle(): ?string
  297.     {
  298.         return $this->NomUtilisateurGoogle;
  299.     }
  300.     public function setNomUtilisateurGoogle(?string $NomUtilisateurGoogle): self
  301.     {
  302.         $this->NomUtilisateurGoogle $NomUtilisateurGoogle;
  303.         return $this;
  304.     }
  305.     public function getCompleted(): ?bool
  306.     {
  307.         return $this->Completed;
  308.     }
  309.     public function setCompleted(bool $Completed): self
  310.     {
  311.         $this->Completed $Completed;
  312.         return $this;
  313.     }
  314.     public function getTokenReset(): ?string
  315.     {
  316.         return $this->TokenReset;
  317.     }
  318.     public function setTokenReset(?string $TokenReset): self
  319.     {
  320.         $this->TokenReset $TokenReset;
  321.         return $this;
  322.     }
  323.     public function getNomOgranisme(): ?string
  324.     {
  325.         return $this->nomOgranisme;
  326.     }
  327.     public function setNomOgranisme(?string $nomOgranisme): self
  328.     {
  329.         $this->nomOgranisme $nomOgranisme;
  330.         return $this;
  331.     }
  332.     public function getAdresse1(): ?string
  333.     {
  334.         return $this->Adresse1;
  335.     }
  336.     public function setAdresse1(?string $Adresse1): self
  337.     {
  338.         $this->Adresse1 $Adresse1;
  339.         return $this;
  340.     }
  341.     public function getAdresse2(): ?string
  342.     {
  343.         return $this->Adresse2;
  344.     }
  345.     public function setAdresse2(string $Adresse2): self
  346.     {
  347.         $this->Adresse2 $Adresse2;
  348.         return $this;
  349.     }
  350.     public function getAdresse3(): ?string
  351.     {
  352.         return $this->Adresse3;
  353.     }
  354.     public function setAdresse3(?string $Adresse3): self
  355.     {
  356.         $this->Adresse3 $Adresse3;
  357.         return $this;
  358.     }
  359.     public function getPhoto(): ?string
  360.     {
  361.         return $this->Photo;
  362.     }
  363.     public function setPhoto(string $Photo): self
  364.     {
  365.         $this->Photo $Photo;
  366.         return $this;
  367.     }
  368.     public function getVille(): ?Ville
  369.     {
  370.         return $this->Ville;
  371.     }
  372.     public function setVille(?Ville $Ville): self
  373.     {
  374.         $this->Ville $Ville;
  375.         return $this;
  376.     }
  377.     public function getTelephoneOrganisme(): ?int
  378.     {
  379.         return $this->TelephoneOrganisme;
  380.     }
  381.     public function setTelephoneOrganisme($TelephoneOrganisme): self
  382.     {
  383.         $this->TelephoneOrganisme $TelephoneOrganisme;
  384.         return $this;
  385.     }
  386.     public function getFaxOrganisme(): ?int
  387.     {
  388.         return $this->FaxOrganisme;
  389.     }
  390.     public function setFaxOrganisme($FaxOrganisme): self
  391.     {
  392.         $this->FaxOrganisme $FaxOrganisme;
  393.         return $this;
  394.     }
  395.     public function getEmailContact(): ?string
  396.     {
  397.         return $this->emailContact;
  398.     }
  399.     public function setEmailContact(string $emailContact): self
  400.     {
  401.         $this->emailContact $emailContact;
  402.         return $this;
  403.     }
  404.     /**
  405.      * @return Collection<int, FormUser>
  406.      */
  407.     public function getFormUsers(): Collection
  408.     {
  409.         return $this->formUsers;
  410.     }
  411.     public function addFormUser(FormUser $formUser): self
  412.     {
  413.         if (!$this->formUsers->contains($formUser)) {
  414.             $this->formUsers[] = $formUser;
  415.             $formUser->setUser($this);
  416.         }
  417.         return $this;
  418.     }
  419.     public function removeFormUser(FormUser $formUser): self
  420.     {
  421.         if ($this->formUsers->removeElement($formUser)) {
  422.             // set the owning side to null (unless already changed)
  423.             if ($formUser->getUser() === $this) {
  424.                 $formUser->setUser(null);
  425.             }
  426.         }
  427.         return $this;
  428.     }
  429.     /**
  430.      * @return Collection<int, Reclamation>
  431.      */
  432.     public function getReclamations(): Collection
  433.     {
  434.         return $this->reclamations;
  435.     }
  436.     public function addReclamation(Reclamation $reclamation): self
  437.     {
  438.         if (!$this->reclamations->contains($reclamation)) {
  439.             $this->reclamations[] = $reclamation;
  440.             $reclamation->setUser($this);
  441.         }
  442.         return $this;
  443.     }
  444.     public function removeReclamation(Reclamation $reclamation): self
  445.     {
  446.         if ($this->reclamations->removeElement($reclamation)) {
  447.             // set the owning side to null (unless already changed)
  448.             if ($reclamation->getUser() === $this) {
  449.                 $reclamation->setUser(null);
  450.             }
  451.         }
  452.         return $this;
  453.     }
  454.     /**
  455.      * @return Collection<int, ReclamationReponse>
  456.      */
  457.     public function getReclamationReponses(): Collection
  458.     {
  459.         return $this->reclamationReponses;
  460.     }
  461.     public function addReclamationReponse(ReclamationReponse $reclamationReponse): self
  462.     {
  463.         if (!$this->reclamationReponses->contains($reclamationReponse)) {
  464.             $this->reclamationReponses[] = $reclamationReponse;
  465.             $reclamationReponse->setUser($this);
  466.         }
  467.         return $this;
  468.     }
  469.     public function removeReclamationReponse(ReclamationReponse $reclamationReponse): self
  470.     {
  471.         if ($this->reclamationReponses->removeElement($reclamationReponse)) {
  472.             // set the owning side to null (unless already changed)
  473.             if ($reclamationReponse->getUser() === $this) {
  474.                 $reclamationReponse->setUser(null);
  475.             }
  476.         }
  477.         return $this;
  478.     }
  479.     public function getExportData()
  480.     {
  481.         return \array_merge([
  482.             'id' => $this->getId(),
  483.             'Nom' => $this->getNom(),
  484.             'Prénom' => $this->getPrenom(),
  485.             'Teléphone' => $this->getTelephoneOrganisme(),
  486.             'Mobile' => $this->getMobile() ?? '',
  487.             'Ville' => $this->getVille() ?? '',
  488.             'Email' => $this->getEmailContact() ?? '',
  489.             'Date de creation' => $this->getCreatedAt() ? $this->getCreatedAt()->format('Y-m-d') : '',
  490.             'Poste' => $this->getIntituleDuPoste() ?? '',
  491.             'Active' => $this->isActive() ?? '',
  492.         ]);
  493.     }
  494.     public function __toString()
  495.     {
  496.         return $this->getEmail();
  497.     }
  498.     /**
  499.      * @return Collection<int, FormUserNote>
  500.      */
  501.     public function getFormUserNotes(): Collection
  502.     {
  503.         return $this->formUserNotes;
  504.     }
  505.     public function addFormUserNote(FormUserNote $formUserNote): self
  506.     {
  507.         if (!$this->formUserNotes->contains($formUserNote)) {
  508.             $this->formUserNotes[] = $formUserNote;
  509.             $formUserNote->setUser($this);
  510.         }
  511.         return $this;
  512.     }
  513.     public function removeFormUserNote(FormUserNote $formUserNote): self
  514.     {
  515.         if ($this->formUserNotes->removeElement($formUserNote)) {
  516.             // set the owning side to null (unless already changed)
  517.             if ($formUserNote->getUser() === $this) {
  518.                 $formUserNote->setUser(null);
  519.             }
  520.         }
  521.         return $this;
  522.     }
  523.      /**
  524.      * @return Collection<int, DemandeNote>
  525.      */
  526.     public function getDemandeNotes(): Collection
  527.     {
  528.         return $this->demandeNotes;
  529.     }
  530.     public function addDemandeNote(DemandeNote $demandeNote): self
  531.     {
  532.         if (!$this->demandeNotes->contains($demandeNote)) {
  533.             $this->demandeNotes[] = $demandeNote;
  534.             $demandeNote->setUser($this);
  535.         }
  536.         return $this;
  537.     }
  538.     public function removeDemandeNote(DemandeNote $demandeNote): self
  539.     {
  540.         if ($this->demandeNotes->removeElement($demandeNote)) {
  541.             // set the owning side to null (unless already changed)
  542.             if ($demandeNote->getUser() === $this) {
  543.                 $demandeNote->setUser(null);
  544.             }
  545.         }
  546.         return $this;
  547.     }
  548.     /**
  549.      * @return Collection<int, Demande>
  550.      */
  551.     public function getDemandeResponsable(): Collection
  552.     {
  553.         return $this->demandeResponsable;
  554.     }
  555.     public function addDemandeResponsable(Demande $demandeResponsable): self
  556.     {
  557.         if (!$this->demandeResponsable->contains($demandeResponsable)) {
  558.             $this->demandeResponsable[] = $demandeResponsable;
  559.             $demandeResponsable->addResponsable($this);
  560.         }
  561.         return $this;
  562.     }
  563.     public function removeDemandeResponsable(Demande $demandeResponsable): self
  564.     {
  565.         if ($this->demandeResponsable->removeElement($demandeResponsable)) {
  566.             $demandeResponsable->removeResponsable($this);
  567.         }
  568.         return $this;
  569.     }
  570.     /**
  571.      * @return Collection<int, FormUser>
  572.      */
  573.     public function getFormUsersResponsable(): Collection
  574.     {
  575.         return $this->formUsersResponsable;
  576.     }
  577.     public function addFormUsersResponsable(FormUser $formUsersResponsable): self
  578.     {
  579.         if (!$this->formUsersResponsable->contains($formUsersResponsable)) {
  580.             $this->formUsersResponsable[] = $formUsersResponsable;
  581.             $formUsersResponsable->addResponsable($this);
  582.         }
  583.         return $this;
  584.     }
  585.     public function removeFormUsersResponsable(FormUser $formUsersResponsable): self
  586.     {
  587.         if ($this->formUsersResponsable->removeElement($formUsersResponsable)) {
  588.             $formUsersResponsable->removeResponsable($this);
  589.         }
  590.         return $this;
  591.     }
  592.     public function isActive(): ?bool
  593.     {
  594.         return $this->Active;
  595.     }
  596.     public function setActive(bool $Active): self
  597.     {
  598.         $this->Active $Active;
  599.         return $this;
  600.     }
  601.     /**
  602.      * @return Collection<int, Reclamation>
  603.      */
  604.     public function getReclamationsResponsable(): Collection
  605.     {
  606.         return $this->reclamationsResponsable;
  607.     }
  608.     public function addReclamationsResponsable(Reclamation $reclamationsResponsable): self
  609.     {
  610.         if (!$this->reclamationsResponsable->contains($reclamationsResponsable)) {
  611.             $this->reclamationsResponsable[] = $reclamationsResponsable;
  612.             $reclamationsResponsable->addResponsable($this);
  613.         }
  614.         return $this;
  615.     }
  616.     public function removeReclamationsResponsable(Reclamation $reclamationsResponsable): self
  617.     {
  618.         if ($this->reclamationsResponsable->removeElement($reclamationsResponsable)) {
  619.             $reclamationsResponsable->removeResponsable($this);
  620.         }
  621.         return $this;
  622.     }
  623.     /**
  624.      * @return Collection<int, Notification>
  625.      */
  626.     public function getNotifications(): Collection
  627.     {
  628.         return $this->notifications;
  629.     }
  630.     public function addNotification(Notification $notification): self
  631.     {
  632.         if (!$this->notifications->contains($notification)) {
  633.             $this->notifications[] = $notification;
  634.             $notification->setUser($this);
  635.         }
  636.         return $this;
  637.     }
  638.     public function removeNotification(Notification $notification): self
  639.     {
  640.         if ($this->notifications->removeElement($notification)) {
  641.             // set the owning side to null (unless already changed)
  642.             if ($notification->getUser() === $this) {
  643.                 $notification->setUser(null);
  644.             }
  645.         }
  646.         return $this;
  647.     }
  648.     /**
  649.      * @return Collection<int, Form>
  650.      */
  651.     public function getFormResponsables(): Collection
  652.     {
  653.         return $this->formResponsables;
  654.     }
  655.     public function addFormResponsable(Form $formResponsable): self
  656.     {
  657.         if (!$this->formResponsables->contains($formResponsable)) {
  658.             $this->formResponsables[] = $formResponsable;
  659.             $formResponsable->addResponsable($this);
  660.         }
  661.         return $this;
  662.     }
  663.     public function removeFormResponsable(Form $formResponsable): self
  664.     {
  665.         if ($this->formResponsables->removeElement($formResponsable)) {
  666.             $formResponsable->removeResponsable($this);
  667.         }
  668.         return $this;
  669.     }
  670. }