src/Entity/User.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  9. use Symfony\Component\Validator\Constraints as Assert;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  12. /**
  13.  * @ORM\Table(name="user")
  14.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  15.  * @ORM\HasLifecycleCallbacks()
  16.  * @UniqueEntity("email")
  17.  */
  18. class User implements UserInterface, \Serializable
  19. {
  20.     public const ROLE_ADMIN = 'ROLE_ADMIN';
  21.     public const ROLE_RH = 'ROLE_RH';
  22.     public const ROLE_USER_ACTIF = 'ROLE_USER_ACTIF';
  23.     public const ROLE_USER_INACTIF = 'ROLE_USER_INACTIF';
  25.     /**
  26.      * @ORM\Id
  27.      * @ORM\GeneratedValue
  28.      * @ORM\Column(type="integer")
  29.      */
  30.     private $id;
  32.     /**
  33.      * @Assert\Length(max=50,min=6,minMessage="Le mot de passe doit faire minimum {{ limit }} caractères.")
  34.      */
  35.     private $plainPassword;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $password;
  42.     /**
  43.      * @ORM\Column(type="string", length=60, unique=true)
  44.      * @Assert\Email
  45.      */
  46.     private $email;
  48.     /**
  49.      * @ORM\ManyToOne(targetEntity="Company", inversedBy="users", fetch="EAGER")
  50.      * @ORM\JoinColumn(name="company_id", referencedColumnName="id")
  51.      */
  52.     private $company;
  54.     /**
  55.      * @ORM\ManyToOne(targetEntity="Role", fetch="EAGER")
  56.      * @ORM\JoinColumn(name="role_id", referencedColumnName="id")
  57.      */
  58.     private $roles;
  60.     /**
  61.      * @ORM\Column(type="string", length=90, nullable=true)
  62.      */
  63.     private $firstname;
  65.     /**
  66.      * @ORM\Column(type="string", length=90, nullable=true)
  67.      */
  68.     private $lastname;
  70.     /**
  71.      * @ORM\Column(type="date", nullable=true)
  72.      */
  73.     private $birth;
  75.     /**
  76.      * @ORM\Column(type="string", length=2, nullable=true)
  77.      */
  78.     private $gender;
  80.     /**
  81.      * @ORM\Column(type="integer", nullable=true)
  82.      */
  83.     private $weight = null;
  85.     /**
  86.      * @ORM\Column(type="float", nullable=true)
  87.      */
  88.     private $height = null;
  90.     /**
  91.      * @ORM\Column(type="json", nullable=true)
  92.      */
  93.     private $punctual_sport;
  95.     /**
  96.      * @ORM\Column(type="boolean", nullable=true)
  97.      */
  98.     private $work_handicapped = null;
  100.     /**
  101.      * @ORM\Column(type="datetime", nullable=true, options={"default": "CURRENT_TIMESTAMP"})
  102.      */
  103.     private $createdAt;
  105.     /**
  106.      * @ORM\Column(type="datetime", nullable=true, options={"default": "CURRENT_TIMESTAMP"})
  107.      */
  108.     private $updatedAt;
  110.     /**
  111.      * @ORM\Column(type="datetime", nullable=true, options={"default": "CURRENT_TIMESTAMP"})
  112.      */
  113.     private $updatedDataConfirmedAt;
  116.     /**
  117.      * @ORM\OneToMany(targetEntity="App\Entity\UserActivity", mappedBy="user", cascade={"persist","remove"})
  118.      */
  119.     private $userActivities;
  121.     /**
  122.      * @ORM\OneToMany(targetEntity=FormationRegistration::class, mappedBy="User",cascade={"remove"})
  123.      */
  124.     private $formations;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=Formation::class, mappedBy="owner", cascade={"remove"})
  128.      */
  129.     private $ownedFormations;
  131.     /**
  132.      * @ORM\OneToMany(targetEntity=UserFavorites::class, mappedBy="user",cascade={"remove"})
  133.      */
  134.     private $favorites;
  136.     /**
  137.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="userTo",cascade={"remove"})
  138.      */
  139.     private $notifications;
  141.     /**
  142.      * @ORM\Column(type="boolean", options={"default": "0"} )
  143.      */
  144.     private $intro = false;
  146.     /**
  147.      * @ORM\Column(type="boolean", options={"default": "0"} )
  148.      */
  149.     private $cgu = false;
  151.     /**
  152.      * @ORM\OneToMany(targetEntity=Log::class, mappedBy="user", cascade={"remove"})
  153.      */
  154.     private $logs;
  156.     /**
  157.      * @ORM\Column(type="boolean", nullable=true)
  158.      */
  159.     private $isContact;
  161.     /**
  162.      * @ORM\Column(type="datetime", nullable=true, options={"default": null})
  163.      */
  164.     private $lastLoginAt;
  166.     /**
  167.      * @ORM\Column(type="string", length=255, nullable=true)
  168.      */
  169.     private $keycloakId;
  171.     /**
  172.      * @ORM\Column(type="datetime", nullable=true)
  173.      */
  174.     private $agreeTermsAt;
  176.     /**
  177.      * @ORM\Column(type="datetime", nullable=true)
  178.      */
  179.     private $agreePrivateDataAt;
  181.     public function __construct()
  182.     {
  183.         $this->userActivities = new ArrayCollection();
  184.         $this->formations = new ArrayCollection();
  185.         $this->ownedFormations = new ArrayCollection();
  186.         $this->notifications = new ArrayCollection();
  187.         $this->logs = new ArrayCollection();
  188.     }
  190.     /**
  191.      * @return mixed
  192.      */
  193.     public function getId()
  194.     {
  195.         return $this->id;
  196.     }
  197.     /**
  198.      * @return mixed
  199.      */
  200.     public function getFirstname()
  201.     {
  202.         return $this->firstname;
  203.     }
  205.     /**
  206.      * @param mixed $firstname
  207.      */
  208.     public function setFirstname($firstname)
  209.     {
  210.         $this->firstname = $firstname;
  211.     }
  213.     /**
  214.      * @return mixed
  215.      */
  216.     public function getLastname()
  217.     {
  218.         return $this->lastname;
  219.     }
  221.     /**
  222.      * @param mixed $lastname
  223.      */
  224.     public function setLastname($lastname)
  225.     {
  226.         $this->lastname = $lastname;
  227.     }
  229.     /**
  230.      * @return mixed
  231.      */
  232.     public function getBirth()
  233.     {
  234.         return $this->birth;
  235.     }
  237.     /**
  238.      * @param mixed $birth
  239.      */
  240.     public function setBirth($birth)
  241.     {
  242.         $this->birth = $birth;
  243.     }
  245.     /**
  246.      * @return mixed
  247.      */
  248.     public function getGender()
  249.     {
  250.         return $this->gender;
  251.     }
  253.     /**
  254.      * @param mixed $gender
  255.      */
  256.     public function setGender($gender)
  257.     {
  258.         $this->gender = $gender;
  259.     }
  262.     /**
  263.      * @return mixed
  264.      */
  265.     public function getWeight()
  266.     {
  267.         return $this->weight;
  268.     }
  270.     /**
  271.      * @param mixed $weight
  272.      */
  273.     public function setWeight($weight)
  274.     {
  275.         $this->weight = $weight;
  276.     }
  278.     /**
  279.      * @return mixed
  280.      */
  281.     public function getHeight()
  282.     {
  283.         return $this->height;
  284.     }
  286.     /**
  287.      * @param mixed $height
  288.      */
  289.     public function setHeight($height)
  290.     {
  291.         $this->height = $height;
  292.     }
  294.     /**
  295.      * @return mixed
  296.      */
  297.     public function getCompany()
  298.     {
  299.         return $this->company;
  300.     }
  302.     /**
  303.      * @param mixed $company
  304.      */
  305.     public function setCompany($company)
  306.     {
  307.         $this->company = $company;
  308.     }
  310.     /**
  311.      * @return mixed
  312.      */
  313.     public function getEmail()
  314.     {
  315.         return $this->email;
  316.     }
  318.     /**
  319.      * Returns the roles granted to the user.
  320.      *
  321.      * <code>
  322.      * public function getRoles()
  323.      * {
  324.      *     return array('ROLE_USER_ACTIF');
  325.      * }
  326.      * </code>
  327.      *
  328.      * Alternatively, the roles might be stored on a ``roles`` property,
  329.      * and populated in any number of different ways when the user object
  330.      * is created.
  331.      *
  332.      * @return (Role|string)[] The user roles
  333.      */
  334.     public function getRoles()
  335.     {
  337.         return $this->roles ? [$this->roles->getName()] : [];
  338.     }
  340.     public static function getStandardRoleNames(): array
  341.     {
  342.         return [
  343.             self::ROLE_USER_ACTIF,
  344.             self::ROLE_USER_INACTIF,
  345.         ];
  346.     }
  348.     public static function getAssignableRoleNames(): array
  349.     {
  350.         return array_merge(self::getStandardRoleNames(), [self::ROLE_RH]);
  351.     }
  353.     public static function getStandardAndManagerRoleNames(): array
  354.     {
  355.         return array_merge(self::getStandardRoleNames(), [self::ROLE_RH]);
  356.     }
  358.     public function isStandardUser(): bool
  359.     {
  360.         return in_array($this->getRoles()[0], self::getStandardRoleNames(), true);
  361.     }
  363.     public function getRoleLabel(): string
  364.     {
  365.         switch ($this->getRoles()[0]) {
  366.             case self::ROLE_USER_ACTIF:
  367.                 return 'Utilisateur actif';
  368.             case self::ROLE_USER_INACTIF:
  369.                 return 'Utilisateur non actif';
  370.             case self::ROLE_RH:
  371.                 return 'Gestionnaire';
  372.             case self::ROLE_ADMIN:
  373.                 return 'Administrateur';
  374.             default:
  375.                 return $this->getRoles()[0];
  376.         }
  377.     }
  379.     /**
  380.      * @param string|Role $role
  381.      * @return bool
  382.      */
  383.     public function hasRole($role)
  384.     {
  385.         $roles = $this->getRoles();
  386.         foreach ($roles as $_role) {
  387.             if($_role == (is_string($role) ? $role : $role->getName()))
  388.                 return true;
  389.         }
  390.         return false;
  391.     }
  393.     /**
  394.      * @return Collection|UserActivity[]
  395.      */
  396.     public function getUserActivities(): Collection
  397.     {
  398.         return $this->userActivities;
  399.     }
  401.     public function addUserActivity(UserActivity $userActivity): self
  402.     {
  403.         if (!$this->userActivities->contains($userActivity)) {
  404.             $this->userActivities[] = $userActivity;
  405.             $userActivity->setUser($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeUserActivity(UserActivity $userActivity): self
  412.     {
  413.         if ($this->userActivities->contains($userActivity)) {
  414.             $this->userActivities->removeElement($userActivity);
  415.             // set the owning side to null (unless already changed)
  416.             if ($userActivity->getUser() === $this) {
  417.                 $userActivity->setUser(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /** Entité associée au compte, distincte des noms retournés pour la sécurité. */
  425.     public function getRole(): ?Role
  426.     {
  427.         return $this->roles;
  428.     }
  430.     public function setRole(?Role $role): void
  431.     {
  432.         $this->roles = $role;
  433.     }
  435.     /**
  436.      * @param mixed $roles
  437.      */
  438.     public function setRoles(Role $roles)
  439.     {
  440.         $this->roles = $roles;
  441.     }
  443.     /**
  444.      * Returns the password used to authenticate the user.
  445.      *
  446.      * This should be the encoded password. On authentication, a plain-text
  447.      * password will be salted, encoded, and then compared to this value.
  448.      *
  449.      * @return string The password
  450.      */
  451.     public function getPassword()
  452.     {
  453.         return $this->password;
  454.     }
  456.     /**
  457.      * Returns the salt that was originally used to encode the password.
  458.      *
  459.      * This can return null if the password was not encoded using a salt.
  460.      *
  461.      * @return string|null The salt
  462.      */
  463.     public function getSalt()
  464.     {
  465.         return null;
  466.     }
  468.     /**
  469.      * Returns the username used to authenticate the user.
  470.      *
  471.      * @return string The username
  472.      */
  473.     public function getUsername()
  474.     {
  475.         return $this->getEmail();
  476.     }
  478.     /**
  479.      * @param mixed $password
  480.      */
  481.     public function setPassword($password)
  482.     {
  483.         $this->password = $password;
  484.     }
  486.     /**
  487.      * @param mixed $email
  488.      */
  489.     public function setEmail($email)
  490.     {
  491.         $this->email = $email;
  492.     }
  494.     /**
  495.      * @return mixed
  496.      */
  497.     public function getCreatedAt()
  498.     {
  499.         return $this->createdAt;
  500.     }
  502.     /**
  503.      * @param mixed $createdAt
  504.      */
  505.     public function setCreatedAt($createdAt): void
  506.     {
  507.         $this->createdAt = $createdAt;
  508.     }
  510.     /**
  511.      * @return mixed
  512.      */
  513.     public function getUpdatedAt()
  514.     {
  515.         return $this->updatedAt;
  516.     }
  518.     /**
  519.      * @param mixed $updatedAt
  520.      */
  521.     public function setUpdatedAt($updatedAt): void
  522.     {
  523.         $this->updatedAt = $updatedAt;
  524.     }
  526.     /**
  527.      * Removes sensitive data from the user.
  528.      *
  529.      * This is important if, at any given point, sensitive information like
  530.      * the plain-text password is stored on this object.
  531.      */
  532.     public function eraseCredentials()
  533.     {
  534.         // TODO: Implement eraseCredentials() method.
  535.     }
  537.     /**
  538.      * String representation of object
  539.      * @link http://php.net/manual/en/serializable.serialize.php
  540.      * @return string the string representation of the object or null
  541.      * @since 5.1.0
  542.      */
  543.     public function serialize()
  544.     {
  545.         return serialize(array(
  546.             $this->id,
  547.             $this->email,
  548.             $this->password,
  549.             $this->roles,
  550.             // see section on salt below
  551.             // $this->salt,
  552.         ));
  553.     }
  555.     /**
  556.      * Constructs the object
  557.      * @link http://php.net/manual/en/serializable.unserialize.php
  558.      * @param string $serialized <p>
  559.      * The string representation of the object.
  560.      * </p>
  561.      * @return void
  562.      * @since 5.1.0
  563.      */
  564.     public function unserialize($serialized)
  565.     {
  566.         list(
  567.             $this->id,
  568.             $this->email,
  569.             $this->password,
  570.             $this->roles,
  571.             // see section on salt below
  572.             // $this->salt
  573.         ) = unserialize($serialized);
  574.     }
  577.     /** @ORM\PrePersist */
  578.     public function onPrePersist()
  579.     {
  580.         $this->createdAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  581.         $this->updatedAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  582.     }
  584.     /** @ORM\PreUpdate */
  585.     public function onPreUpdate()
  586.     {
  587.         $this->updatedAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  588.     }
  590.     /**
  591.      * @return mixed
  592.      */
  593.     public function getPlainPassword()
  594.     {
  595.         return $this->plainPassword;
  596.     }
  598.     /**
  599.      * @param mixed $plainPassword
  600.      */
  601.     public function setPlainPassword($plainPassword): void
  602.     {
  603.         $this->plainPassword = $plainPassword;
  604.     }
  606.     /**
  607.      * @return Collection|FormationRegistration[]
  608.      */
  609.     public function getFormations(): Collection
  610.     {
  611.         return $this->formations;
  612.     }
  614.     public function addFormation(FormationRegistration $formation): self
  615.     {
  616.         if (!$this->formations->contains($formation)) {
  617.             $this->formations[] = $formation;
  618.             $formation->setUser($this);
  619.         }
  621.         return $this;
  622.     }
  624.     public function removeFormation(FormationRegistration $formation): self
  625.     {
  626.         if ($this->formations->removeElement($formation)) {
  627.             // set the owning side to null (unless already changed)
  628.             if ($formation->getUser() === $this) {
  629.                 $formation->setUser(null);
  630.             }
  631.         }
  633.         return $this;
  634.     }
  636.     public function getOwnedFormations(): Collection
  637.     {
  638.         return $this->ownedFormations;
  639.     }
  641.     public function addOwnedFormation(Formation $formation): self
  642.     {
  643.         if (!$this->ownedFormations->contains($formation)) {
  644.             $this->ownedFormations[] = $formation;
  645.             $formation->setOwner($this);
  646.         }
  648.         return $this;
  649.     }
  651.     public function removeOwnedFormation(Formation $formation): self
  652.     {
  653.         if ($this->ownedFormations->removeElement($formation)) {
  654.             if ($formation->getOwner() === $this) {
  655.                 $formation->setOwner(null);
  656.             }
  657.         }
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return Collection|Notification[]
  664.      */
  665.     public function getNotifications(): Collection
  666.     {
  667.         return $this->notifications;
  668.     }
  670.     public function addNotification(Notification $notification): self
  671.     {
  672.         if (!$this->notifications->contains($notification)) {
  673.             $this->notifications[] = $notification;
  674.             $notification->setUserTo($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeNotification(Notification $notification): self
  681.     {
  682.         if ($this->notifications->removeElement($notification)) {
  683.             // set the owning side to null (unless already changed)
  684.             if ($notification->getUserTo() === $this) {
  685.                 $notification->setUserTo(null);
  686.             }
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * @return bool
  694.      */
  695.     public function isIntro(): bool
  696.     {
  697.         return $this->intro;
  698.     }
  700.     /**
  701.      * @param bool $intro
  702.      */
  703.     public function setIntro(bool $intro): void
  704.     {
  705.         $this->intro = $intro;
  706.     }
  708.     /**
  709.      * @return bool
  710.      */
  711.     public function getCgu(): bool
  712.     {
  713.         return $this->cgu;
  714.     }
  716.     /**
  717.      * @param bool $cgu
  718.      */
  719.     public function setCgu(bool $cgu): void
  720.     {
  721.         $this->cgu = $cgu;
  722.     }
  724.     /**
  725.      * @return null
  726.      */
  727.     public function getWorkHandicapped()
  728.     {
  729.         return $this->work_handicapped;
  730.     }
  732.     /**
  733.      * @param null $work_handicapped
  734.      */
  735.     public function setWorkHandicapped($work_handicapped): void
  736.     {
  737.         $this->work_handicapped = $work_handicapped;
  738.     }
  740.     /**
  741.      * @return
  742.      */
  743.     public function getPunctualSport()
  744.     {
  745.         return $this->punctual_sport;
  746.     }
  748.     /**
  749.      * @param $punctual_sport
  750.      */
  751.     public function setPunctualSport($punctual_sport): void
  752.     {
  753.         $this->punctual_sport = $punctual_sport;
  754.     }
  756.     /**
  757.      * @return mixed
  758.      */
  759.     public function getUpdatedDataConfirmedAt()
  760.     {
  761.         return $this->updatedDataConfirmedAt;
  762.     }
  764.     /**
  765.      * @param mixed $updatedDataConfirmedAt
  766.      */
  767.     public function setUpdatedDataConfirmedAt($updatedDataConfirmedAt): void
  768.     {
  769.         $this->updatedDataConfirmedAt = $updatedDataConfirmedAt;
  770.     }
  772.     public function getIsContact(): ?bool
  773.     {
  774.         return $this->isContact;
  775.     }
  777.     public function setIsContact(?bool $isContact): self
  778.     {
  779.         $this->isContact = $isContact;
  781.         return $this;
  782.     }
  784.     /**
  785.      * @return mixed
  786.      */
  787.     public function getLastLoginAt()
  788.     {
  789.         return $this->lastLoginAt;
  790.     }
  792.     /**
  793.      * @param mixed $lastLoginAt
  794.      */
  795.     public function setLastLoginAt($lastLoginAt): void
  796.     {
  797.         $this->lastLoginAt = $lastLoginAt;
  798.     }
  800.     //    /**
  801. //     * @ORM\PrePersist
  802. //     * @ORM\PreUpdate
  803. //     */
  804. //    public function updatedTimestamps(): void
  805. //    {
  806. //        $this->setUpdatedDataConfirmedAt(new \DateTime());
  807. //    }
  808.     /**
  809.      * @return mixed
  810.      */
  811.     public function getKeycloakId()
  812.     {
  813.         return $this->keycloakId;
  814.     }
  816.     /**
  817.      * @param mixed $keycloakId
  818.      */
  819.     public function setKeycloakId($keycloakId): void
  820.     {
  821.         $this->keycloakId = $keycloakId;
  822.     }
  824.     /**
  825.      * @return mixed
  826.      */
  827.     public function getAgreeTermsAt()
  828.     {
  829.         return $this->agreeTermsAt;
  830.     }
  832.     /**
  833.      * @param mixed $agreeTermsAt
  834.      */
  835.     public function setAgreeTermsAt($agreeTermsAt): void
  836.     {
  837.         $this->agreeTermsAt = $agreeTermsAt;
  838.     }
  840.     /**
  841.      * @return mixed
  842.      */
  843.     public function getAgreePrivateDataAt()
  844.     {
  845.         return $this->agreePrivateDataAt;
  846.     }
  848.     /**
  849.      * @param mixed $agreePrivateDataAt
  850.      */
  851.     public function setAgreePrivateDataAt($agreePrivateDataAt): void
  852.     {
  853.         $this->agreePrivateDataAt = $agreePrivateDataAt;
  854.     }
  855. }