src/Entity/User.php line 24

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 Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  13. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
  14. use Symfony\Component\HttpFoundation\File\File;
  15. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  17. /**
  18.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  19.  */
  20. #[ORM\Entity(repositoryClass: UserRepository::class)]
  21. #[ORM\Table(name: '`user`')]
  22. #[ORM\HasLifecycleCallbacks()]
  23. #[Vich\Uploadable]
  24. class User implements UserInterface, PasswordAuthenticatedUserInterface, \Serializable
  25. {
  26.     public const ROLE_SUPER_ADMIN   = 'ROLE_SUPER_ADMIN';
  27.     public const ROLE_ADMIN         = 'ROLE_ADMIN';
  28.     public const ROLE_RESPONSABLE   = 'ROLE_RESPONSABLE';
  29.     public const ROLE_EMPLOYEE      = 'ROLE_EMPLOYEE';
  31.     const strEtat = [
  32.                     0 => 'Inactif',
  33.                     1 => 'Actif',
  34.                     2 => 'Supprimé'
  35.     ];
  37.     #[ORM\Id]
  38.     #[ORM\GeneratedValue]
  39.     #[ORM\Column(type: 'integer')]
  40.     private $id;
  42.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  43.     #[Assert\NotBlank()]
  44.     #[Assert\Email()]
  45.     private $email;
  47.     #[ORM\Column(type: 'json')]
  48.     private $roles = [];
  50.     #[ORM\Column(type: 'string')]
  51.     private $password;
  53.     #[Assert\Length(max:4096)]
  54.     private $plainPassword;
  56.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  57.     private $firstName;
  59.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  60.     private $lastName;
  62.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  63.     private $civility;
  65.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  66.     private $userName;
  68.     #[ORM\Column(type: 'string', length: 30, nullable: true)]
  69.     private $phoneNumber;
  71.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  72.     private $fonction;
  74.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  75.     private $adresse;
  77.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  78.     private $pays;
  80.     #[ORM\Column(type: 'boolean', nullable: true)]
  81.     private $active;
  83.     #[ORM\Column(type: 'boolean', nullable: true)]
  84.     private $etat = 1;
  86.     #[ORM\Column(type: 'integer')]
  87.     private $idParent;
  89.     #[ORM\Column(type: 'datetime', nullable: true)]
  90.     private $lastActivity;
  92.     #[ORM\Column(type: 'datetime', nullable: true)]
  93.     private $lastConnected;
  95.     #[ORM\ManyToMany(targetEntity: Groupe::class, mappedBy: 'listesOfEmployes')]
  96.     private $groupes;
  98.     #[ORM\OneToMany(mappedBy: 'responsable', targetEntity: Groupe::class)]
  99.     private $responsableGroupe;
  101.     /**
  102.      * @var File|null
  103.      * @Vich\UploadableField(mapping="user_profile", fileNameProperty="imageProfile")
  104.      * @Assert\File(
  105.      *     maxSize = "2M",
  106.      *     mimeTypes = {"image/jpeg", "image/png"},
  107.      *     maxSizeMessage = "Le fichier est trop volumineux. Sa taille ne doit pas dépasser 2M",
  108.      *     mimeTypesMessage = "Veuillez télécharger une image valide!"
  109.      * )
  110.      */
  111.     private $imageProfileFile;
  113.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  114.     private $imageProfile;
  116.     #[ORM\Column(type: 'datetime')]
  117.     private $createdAt;
  119.     #[ORM\Column(type: 'datetime', nullable: true)]
  120.     private $updatedAt;
  122.     #[ORM\Column(type: 'integer', nullable: true)]
  123.     private $createdBy;
  125.     #[ORM\Column(type: 'integer', nullable: true)]
  126.     private $updatedBy;
  128.     #[ORM\Column(type: "boolean")]
  129.     private $isVerified = false;
  131.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Comment::class)]
  132.     private $comments;
  134.     public function __construct()
  135.     {
  136.         $this->idParent = 0;
  137.         $this->groupes = new ArrayCollection();
  138.         $this->responsableGroupe = new ArrayCollection();
  139.         $this->comments = new ArrayCollection();
  140.     }
  142.     public function serialize()
  143.     {
  144.         return serialize(array(
  145.             $this->id,
  146.             $this->email,
  147.             $this->firstName,
  148.             $this->lastName,
  149.             $this->password,
  150.         ));
  151.     }
  153.     public function unserialize($serialized)
  154.     {
  155.         list(
  156.             $this->id,
  157.             $this->email,
  158.             $this->firstName,
  159.             $this->lastName,
  160.             $this->password,
  161.         ) = unserialize($serialized);
  162.     }
  164.     public function getId(): ?int
  165.     {
  166.         return $this->id;
  167.     }
  169.     public function getEmail(): ?string
  170.     {
  171.         return $this->email;
  172.     }
  174.     public function setEmail(string $email): self
  175.     {
  176.         $this->email = $email;
  178.         return $this;
  179.     }
  181.     /**
  182.      * A visual identifier that represents this user.
  183.      *
  184.      * @see UserInterface
  185.      */
  186.     public function getUserIdentifier(): string
  187.     {
  188.         return (string) $this->email;
  189.     }
  191.     /**
  192.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  193.      */
  194.     public function getUsername(): string
  195.     {
  196.         return (string) $this->email;
  197.     }
  199.     /**
  200.      * @see UserInterface
  201.      */
  202.     public function getRoles(): array
  203.     {
  204.         $roles = $this->roles;
  205.         // guarantee every user at least has ROLE_USER
  206.         $roles[] = 'ROLE_USER';
  208.         return array_unique($roles);
  209.     }
  211.     public function setRoles(array $roles): self
  212.     {
  213.         $this->roles = $roles;
  215.         return $this;
  216.     }
  218.     /**
  219.      * @see PasswordAuthenticatedUserInterface
  220.      */
  221.     public function getPassword(): string
  222.     {
  223.         return $this->password;
  224.     }
  226.     public function setPassword(string $password): self
  227.     {
  228.         $this->password = $password;
  230.         return $this;
  231.     }
  233.     public function getPlainPassword()
  234.     {
  235.         return $this->plainPassword;
  236.     }
  238.     public function setPlainPassword($password)
  239.     {
  240.         $this->plainPassword = $password;
  241.     }
  243.     /**
  244.      * Returning a salt is only needed, if you are not using a modern
  245.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  246.      *
  247.      * @see UserInterface
  248.      */
  249.     public function getSalt(): ?string
  250.     {
  251.         return null;
  252.     }
  254.     /**
  255.      * @see UserInterface
  256.      */
  257.     public function eraseCredentials()
  258.     {
  259.         // If you store any temporary, sensitive data on the user, clear it here
  260.         // $this->plainPassword = null;
  261.     }
  263.     public function getFirstName(): ?string
  264.     {
  265.         return $this->firstName;
  266.     }
  268.     public function setFirstName(string $firstName): self
  269.     {
  270.         $this->firstName = $firstName;
  272.         return $this;
  273.     }
  275.     public function getLastName(): ?string
  276.     {
  277.         return $this->lastName;
  278.     }
  280.     public function setLastName(string $lastName): self
  281.     {
  282.         $this->lastName = $lastName;
  284.         return $this;
  285.     }
  287.     public function getCivility(): ?string
  288.     {
  289.         return $this->civility;
  290.     }
  292.     public function setCivility(?string $civility): self
  293.     {
  294.         $this->civility = $civility;
  296.         return $this;
  297.     }
  299.     public function setUserName(string $userName): self
  300.     {
  301.         $this->userName = $userName;
  303.         return $this;
  304.     }
  306.     public function getPhoneNumber(): ?string
  307.     {
  308.         return $this->phoneNumber;
  309.     }
  311.     public function setPhoneNumber(?string $phoneNumber): self
  312.     {
  313.         $this->phoneNumber = $phoneNumber;
  315.         return $this;
  316.     }
  318.     public function getFonction(): ?string
  319.     {
  320.         return $this->fonction;
  321.     }
  323.     public function setFonction(?string $fonction): self
  324.     {
  325.         $this->fonction = $fonction;
  327.         return $this;
  328.     }
  330.     public function getAdresse(): ?string
  331.     {
  332.         return $this->adresse;
  333.     }
  335.     public function setAdresse(?string $adresse): self
  336.     {
  337.         $this->adresse = $adresse;
  339.         return $this;
  340.     }
  342.     public function getPays(): ?string
  343.     {
  344.         return $this->pays;
  345.     }
  347.     public function setPays(?string $pays): self
  348.     {
  349.         $this->pays = $pays;
  351.         return $this;
  352.     }
  354.     public function getImageProfile(): ?string
  355.     {
  356.         return $this->imageProfile;
  357.     }
  359.     public function setImageProfile(?string $imageProfile): self
  360.     {
  361.         $this->imageProfile = $imageProfile;
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return null|File
  368.      */
  369.     public function getImageProfileFile(): ?File
  370.     {
  371.         return $this->imageProfileFile;
  372.     }
  374.     /**
  375.      * @param null|File $imageProfileFile
  376.      * @return self
  377.      */
  378.     public function setImageProfileFile(?File $imageProfileFile = null): self
  379.     {
  380.         $this->imageProfileFile = $imageProfileFile;
  382.         return $this;
  383.     }
  385.     public function getActive(): ?bool
  386.     {
  387.         return $this->active;
  388.     }
  390.     public function setActive(?bool $active): self
  391.     {
  392.         $this->active = $active;
  394.         return $this;
  395.     }
  397.     public function getEtat(): ?bool
  398.     {
  399.         return $this->etat;
  400.     }
  402.     public function setEtat(?bool $etat): self
  403.     {
  404.         $this->etat = $etat;
  406.         return $this;
  407.     }
  409.     public function getIdParent(): ?int
  410.     {
  411.         return $this->idParent;
  412.     }
  414.     public function setIdParent(int $idParent): self
  415.     {
  416.         $this->idParent = $idParent;
  418.         return $this;
  419.     }
  421.     public function getLastActivity(): ?\DateTimeInterface
  422.     {
  423.         return $this->lastActivity;
  424.     }
  426.     public function setLastActivity(?\DateTimeInterface $lastActivity): self
  427.     {
  428.         $this->lastActivity = $lastActivity;
  430.         return $this;
  431.     }
  433.     public function getLastConnected(): ?\DateTimeInterface
  434.     {
  435.         return $this->lastConnected;
  436.     }
  438.     public function setLastConnected(?\DateTimeInterface $lastConnected): self
  439.     {
  440.         $this->lastConnected = $lastConnected;
  442.         return $this;
  443.     }
  445.     /**
  446.      * @return Collection|Groupe[]
  447.      */
  448.     public function getGroupes(): Collection
  449.     {
  450.         return $this->groupes;
  451.     }
  453.     public function addGroupe(Groupe $groupe): self
  454.     {
  455.         if (!$this->groupes->contains($groupe)) {
  456.             $this->groupes[] = $groupe;
  457.             $groupe->addListesOfEmploye($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeGroupe(Groupe $groupe): self
  464.     {
  465.         if ($this->groupes->removeElement($groupe)) {
  466.             $groupe->removeListesOfEmploye($this);
  467.         }
  469.         return $this;
  470.     }
  472.     /**
  473.      * @return Collection|Groupe[]
  474.      */
  475.     public function getResponsableGroupe(): Collection
  476.     {
  477.         return $this->responsableGroupe;
  478.     }
  480.     public function addResponsableGroupe(Groupe $responsableGroupe): self
  481.     {
  482.         if (!$this->responsableGroupe->contains($responsableGroupe)) {
  483.             $this->responsableGroupe[] = $responsableGroupe;
  484.             $responsableGroupe->setResponsable($this);
  485.         }
  487.         return $this;
  488.     }
  490.     public function removeResponsableGroupe(Groupe $responsableGroupe): self
  491.     {
  492.         if ($this->responsableGroupe->removeElement($responsableGroupe)) {
  493.             // set the owning side to null (unless already changed)
  494.             if ($responsableGroupe->getResponsable() === $this) {
  495.                 $responsableGroupe->setResponsable(null);
  496.             }
  497.         }
  499.         return $this;
  500.     }
  502.     public function getCreatedAt(): ?\DateTimeInterface
  503.     {
  504.         return $this->createdAt;
  505.     }
  507.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  508.     {
  509.         $this->createdAt = $createdAt;
  511.         return $this;
  512.     }
  514.     public function getUpdatedAt(): ?\DateTimeInterface
  515.     {
  516.         return $this->updatedAt;
  517.     }
  519.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  520.     {
  521.         $this->updatedAt = $updatedAt;
  523.         return $this;
  524.     }
  526.     public function getCreatedBy(): ?int
  527.     {
  528.         return $this->createdBy;
  529.     }
  531.     public function setCreatedBy(?int $createdBy): self
  532.     {
  533.         $this->createdBy = $createdBy;
  535.         return $this;
  536.     }
  538.     public function getUpdatedBy(): ?int
  539.     {
  540.         return $this->updatedBy;
  541.     }
  543.     public function setUpdatedBy(?int $updatedBy): self
  544.     {
  545.         $this->updatedBy = $updatedBy;
  547.         return $this;
  548.     }
  550.     public function getFullName(): string
  551.     {
  552.         return $this->firstName.' '.$this->lastName;
  553.     }
  555.     #[ORM\PrePersist]
  556.     public function onPrePersist()
  557.     {
  558.         if(empty($this->createdAt)){
  559.             $this->createdAt = new \DateTime();
  560.         }
  561.     }
  563.     #[ORM\PreUpdate]
  564.     public function onPreUpdate()
  565.     {
  566.         $this->updatedAt    = new \DateTime();
  567.         $this->lastActivity = new \DateTime();
  568.     }
  570.     /**
  571.      * @return bool whether the user is active or not
  572.      */
  574.     public function isActiveNow()
  575.     {
  577.         $delay = new \DateTime('1 minutes ago');
  579.         return($this->getlastActivity() > $delay);
  581.     }
  583.     public function isVerified(): bool
  584.     {
  585.         return $this->isVerified;
  586.     }
  588.     public function setIsVerified(bool $isVerified): self
  589.     {
  590.         $this->isVerified = $isVerified;
  592.         return $this;
  593.     }
  595.     public function getIsVerified(): bool
  596.     {
  597.         return $this->isVerified;
  598.     }
  600.     public function getStrRoles($roles): string
  601.     {
  602.         $strRoles = '';
  603.         if(in_array(self::ROLE_SUPER_ADMIN, $roles)){
  604.             $strRoles = 'Super Admin';
  605.         }elseif(in_array(self::ROLE_RESPONSABLE, $roles)){
  606.             $strRoles = 'Résponsable';
  607.         }elseif(in_array(self::ROLE_EMPLOYEE, $roles)){
  608.             $strRoles = 'Employée';
  609.         }
  612.         return $strRoles;
  613.     }
  615.     /**
  616.      * @return Collection|Comment[]
  617.      */
  618.     public function getComments(): Collection
  619.     {
  620.         return $this->comments;
  621.     }
  623.     public function addComment(Comment $comment): self
  624.     {
  625.         if (!$this->comments->contains($comment)) {
  626.             $this->comments[] = $comment;
  627.             $comment->setAuthor($this);
  628.         }
  630.         return $this;
  631.     }
  633.     public function removeComment(Comment $comment): self
  634.     {
  635.         if ($this->comments->removeElement($comment)) {
  636.             // set the owning side to null (unless already changed)
  637.             if ($comment->getAuthor() === $this) {
  638.                 $comment->setAuthor(null);
  639.             }
  640.         }
  642.         return $this;
  643.     }
  644. }