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\ManyToOne(targetEntity="App\Entity\Department")
  123.      */
  124.     private $department;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=FormationRegistration::class, mappedBy="User",cascade={"remove"})
  128.      */
  129.     private $formations;
  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\ManyToOne(targetEntity=Job::class, inversedBy="user")
  158.      */
  159.     private $job;
  161.     /**
  162.      * @ORM\Column(type="boolean", nullable=true)
  163.      */
  164.     private $isContact;
  166.     /**
  167.      * @ORM\Column(type="datetime", nullable=true, options={"default": null})
  168.      */
  169.     private $lastLoginAt;
  171.     /**
  172.      * @ORM\Column(type="string", length=255, nullable=true)
  173.      */
  174.     private $keycloakId;
  176.     /**
  177.      * @ORM\ManyToOne(targetEntity=Site::class, inversedBy="user")
  178.      */
  179.     private $site;
  181.     /**
  182.      * @ORM\Column(type="datetime", nullable=true)
  183.      */
  184.     private $agreeTermsAt;
  186.     /**
  187.      * @ORM\Column(type="datetime", nullable=true)
  188.      */
  189.     private $agreePrivateDataAt;
  191.     public function __construct()
  192.     {
  193.         $this->userActivities = new ArrayCollection();
  194.         $this->formations = new ArrayCollection();
  195.         $this->notifications = new ArrayCollection();
  196.         $this->logs = new ArrayCollection();
  197.     }
  199.     /**
  200.      * @return mixed
  201.      */
  202.     public function getId()
  203.     {
  204.         return $this->id;
  205.     }
  206.     /**
  207.      * @return mixed
  208.      */
  209.     public function getFirstname()
  210.     {
  211.         return $this->firstname;
  212.     }
  214.     /**
  215.      * @param mixed $firstname
  216.      */
  217.     public function setFirstname($firstname)
  218.     {
  219.         $this->firstname = $firstname;
  220.     }
  222.     /**
  223.      * @return mixed
  224.      */
  225.     public function getLastname()
  226.     {
  227.         return $this->lastname;
  228.     }
  230.     /**
  231.      * @param mixed $lastname
  232.      */
  233.     public function setLastname($lastname)
  234.     {
  235.         $this->lastname = $lastname;
  236.     }
  238.     /**
  239.      * @return mixed
  240.      */
  241.     public function getBirth()
  242.     {
  243.         return $this->birth;
  244.     }
  246.     /**
  247.      * @param mixed $birth
  248.      */
  249.     public function setBirth($birth)
  250.     {
  251.         $this->birth = $birth;
  252.     }
  254.     /**
  255.      * @return mixed
  256.      */
  257.     public function getGender()
  258.     {
  259.         return $this->gender;
  260.     }
  262.     /**
  263.      * @param mixed $gender
  264.      */
  265.     public function setGender($gender)
  266.     {
  267.         $this->gender = $gender;
  268.     }
  271.     /**
  272.      * @return mixed
  273.      */
  274.     public function getWeight()
  275.     {
  276.         return $this->weight;
  277.     }
  279.     /**
  280.      * @param mixed $weight
  281.      */
  282.     public function setWeight($weight)
  283.     {
  284.         $this->weight = $weight;
  285.     }
  287.     /**
  288.      * @return mixed
  289.      */
  290.     public function getHeight()
  291.     {
  292.         return $this->height;
  293.     }
  295.     /**
  296.      * @param mixed $height
  297.      */
  298.     public function setHeight($height)
  299.     {
  300.         $this->height = $height;
  301.     }
  303.     /**
  304.      * @return mixed
  305.      */
  306.     public function getCompany()
  307.     {
  308.         return $this->company;
  309.     }
  311.     /**
  312.      * @param mixed $company
  313.      */
  314.     public function setCompany($company)
  315.     {
  316.         $this->company = $company;
  317.     }
  319.     /**
  320.      * @return mixed
  321.      */
  322.     public function getEmail()
  323.     {
  324.         return $this->email;
  325.     }
  327.     /**
  328.      * Returns the roles granted to the user.
  329.      *
  330.      * <code>
  331.      * public function getRoles()
  332.      * {
  333.      *     return array('ROLE_USER_ACTIF');
  334.      * }
  335.      * </code>
  336.      *
  337.      * Alternatively, the roles might be stored on a ``roles`` property,
  338.      * and populated in any number of different ways when the user object
  339.      * is created.
  340.      *
  341.      * @return (Role|string)[] The user roles
  342.      */
  343.     public function getRoles()
  344.     {
  346.         return array($this->roles->getName());
  347.     }
  349.     public static function getStandardRoleNames(): array
  350.     {
  351.         return [
  352.             self::ROLE_USER_ACTIF,
  353.             self::ROLE_USER_INACTIF,
  354.         ];
  355.     }
  357.     public static function getAssignableRoleNames(): array
  358.     {
  359.         return array_merge(self::getStandardRoleNames(), [self::ROLE_RH]);
  360.     }
  362.     public static function getStandardAndManagerRoleNames(): array
  363.     {
  364.         return array_merge(self::getStandardRoleNames(), [self::ROLE_RH]);
  365.     }
  367.     public function isStandardUser(): bool
  368.     {
  369.         return in_array($this->getRoles()[0], self::getStandardRoleNames(), true);
  370.     }
  372.     public function getRoleLabel(): string
  373.     {
  374.         switch ($this->getRoles()[0]) {
  375.             case self::ROLE_USER_ACTIF:
  376.                 return 'Utilisateur actif';
  377.             case self::ROLE_USER_INACTIF:
  378.                 return 'Utilisateur non actif';
  379.             case self::ROLE_RH:
  380.                 return 'Gestionnaire';
  381.             case self::ROLE_ADMIN:
  382.                 return 'Administrateur';
  383.             default:
  384.                 return $this->getRoles()[0];
  385.         }
  386.     }
  388.     /**
  389.      * @param string|Role $role
  390.      * @return bool
  391.      */
  392.     public function hasRole($role)
  393.     {
  394.         $roles = $this->getRoles();
  395.         foreach ($roles as $_role) {
  396.             if($_role == (is_string($role) ? $role : $role->getName()))
  397.                 return true;
  398.         }
  399.         return false;
  400.     }
  402.     /**
  403.      * @return Collection|UserActivity[]
  404.      */
  405.     public function getUserActivities(): Collection
  406.     {
  407.         return $this->userActivities;
  408.     }
  410.     public function addUserActivity(UserActivity $userActivity): self
  411.     {
  412.         if (!$this->userActivities->contains($userActivity)) {
  413.             $this->userActivities[] = $userActivity;
  414.             $userActivity->setUser($this);
  415.         }
  417.         return $this;
  418.     }
  420.     public function removeUserActivity(UserActivity $userActivity): self
  421.     {
  422.         if ($this->userActivities->contains($userActivity)) {
  423.             $this->userActivities->removeElement($userActivity);
  424.             // set the owning side to null (unless already changed)
  425.             if ($userActivity->getUser() === $this) {
  426.                 $userActivity->setUser(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * @param mixed $roles
  435.      */
  436.     public function setRoles(Role $roles)
  437.     {
  438.         $this->roles = $roles;
  439.     }
  441.     /**
  442.      * Returns the password used to authenticate the user.
  443.      *
  444.      * This should be the encoded password. On authentication, a plain-text
  445.      * password will be salted, encoded, and then compared to this value.
  446.      *
  447.      * @return string The password
  448.      */
  449.     public function getPassword()
  450.     {
  451.         return $this->password;
  452.     }
  454.     /**
  455.      * Returns the salt that was originally used to encode the password.
  456.      *
  457.      * This can return null if the password was not encoded using a salt.
  458.      *
  459.      * @return string|null The salt
  460.      */
  461.     public function getSalt()
  462.     {
  463.         return null;
  464.     }
  466.     /**
  467.      * Returns the username used to authenticate the user.
  468.      *
  469.      * @return string The username
  470.      */
  471.     public function getUsername()
  472.     {
  473.         return $this->getEmail();
  474.     }
  476.     /**
  477.      * @param mixed $password
  478.      */
  479.     public function setPassword($password)
  480.     {
  481.         $this->password = $password;
  482.     }
  484.     /**
  485.      * @param mixed $email
  486.      */
  487.     public function setEmail($email)
  488.     {
  489.         $this->email = $email;
  490.     }
  492.     /**
  493.      * @return mixed
  494.      */
  495.     public function getCreatedAt()
  496.     {
  497.         return $this->createdAt;
  498.     }
  500.     /**
  501.      * @param mixed $createdAt
  502.      */
  503.     public function setCreatedAt($createdAt): void
  504.     {
  505.         $this->createdAt = $createdAt;
  506.     }
  508.     /**
  509.      * @return mixed
  510.      */
  511.     public function getUpdatedAt()
  512.     {
  513.         return $this->updatedAt;
  514.     }
  516.     /**
  517.      * @param mixed $updatedAt
  518.      */
  519.     public function setUpdatedAt($updatedAt): void
  520.     {
  521.         $this->updatedAt = $updatedAt;
  522.     }
  524.     /**
  525.      * Removes sensitive data from the user.
  526.      *
  527.      * This is important if, at any given point, sensitive information like
  528.      * the plain-text password is stored on this object.
  529.      */
  530.     public function eraseCredentials()
  531.     {
  532.         // TODO: Implement eraseCredentials() method.
  533.     }
  535.     /**
  536.      * String representation of object
  537.      * @link http://php.net/manual/en/serializable.serialize.php
  538.      * @return string the string representation of the object or null
  539.      * @since 5.1.0
  540.      */
  541.     public function serialize()
  542.     {
  543.         return serialize(array(
  544.             $this->id,
  545.             $this->email,
  546.             $this->password,
  547.             $this->roles,
  548.             // see section on salt below
  549.             // $this->salt,
  550.         ));
  551.     }
  553.     /**
  554.      * Constructs the object
  555.      * @link http://php.net/manual/en/serializable.unserialize.php
  556.      * @param string $serialized <p>
  557.      * The string representation of the object.
  558.      * </p>
  559.      * @return void
  560.      * @since 5.1.0
  561.      */
  562.     public function unserialize($serialized)
  563.     {
  564.         list(
  565.             $this->id,
  566.             $this->email,
  567.             $this->password,
  568.             $this->roles,
  569.             // see section on salt below
  570.             // $this->salt
  571.         ) = unserialize($serialized);
  572.     }
  575.     /** @ORM\PrePersist */
  576.     public function onPrePersist()
  577.     {
  578.         $this->createdAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  579.         $this->updatedAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  580.     }
  582.     /** @ORM\PreUpdate */
  583.     public function onPreUpdate()
  584.     {
  585.         $this->updatedAt = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  586.     }
  588.     public function getDepartment(): ?Department
  589.     {
  590.         return $this->department;
  591.     }
  593.     public function setDepartment(?Department $department): self
  594.     {
  595.         $this->department = $department;
  597.         return $this;
  598.     }
  600.     /**
  601.      * @return mixed
  602.      */
  603.     public function getPlainPassword()
  604.     {
  605.         return $this->plainPassword;
  606.     }
  608.     /**
  609.      * @param mixed $plainPassword
  610.      */
  611.     public function setPlainPassword($plainPassword): void
  612.     {
  613.         $this->plainPassword = $plainPassword;
  614.     }
  616.     /**
  617.      * @return Collection|FormationRegistration[]
  618.      */
  619.     public function getFormations(): Collection
  620.     {
  621.         return $this->formations;
  622.     }
  624.     public function addFormation(FormationRegistration $formation): self
  625.     {
  626.         if (!$this->formations->contains($formation)) {
  627.             $this->formations[] = $formation;
  628.             $formation->setUser($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeFormation(FormationRegistration $formation): self
  635.     {
  636.         if ($this->formations->removeElement($formation)) {
  637.             // set the owning side to null (unless already changed)
  638.             if ($formation->getUser() === $this) {
  639.                 $formation->setUser(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection|Notification[]
  648.      */
  649.     public function getNotifications(): Collection
  650.     {
  651.         return $this->notifications;
  652.     }
  654.     public function addNotification(Notification $notification): self
  655.     {
  656.         if (!$this->notifications->contains($notification)) {
  657.             $this->notifications[] = $notification;
  658.             $notification->setUserTo($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removeNotification(Notification $notification): self
  665.     {
  666.         if ($this->notifications->removeElement($notification)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($notification->getUserTo() === $this) {
  669.                 $notification->setUserTo(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  676.     /**
  677.      * @return bool
  678.      */
  679.     public function isIntro(): bool
  680.     {
  681.         return $this->intro;
  682.     }
  684.     /**
  685.      * @param bool $intro
  686.      */
  687.     public function setIntro(bool $intro): void
  688.     {
  689.         $this->intro = $intro;
  690.     }
  692.     /**
  693.      * @return bool
  694.      */
  695.     public function getCgu(): bool
  696.     {
  697.         return $this->cgu;
  698.     }
  700.     /**
  701.      * @param bool $cgu
  702.      */
  703.     public function setCgu(bool $cgu): void
  704.     {
  705.         $this->cgu = $cgu;
  706.     }
  708.     /**
  709.      * @return null
  710.      */
  711.     public function getWorkHandicapped()
  712.     {
  713.         return $this->work_handicapped;
  714.     }
  716.     /**
  717.      * @param null $work_handicapped
  718.      */
  719.     public function setWorkHandicapped($work_handicapped): void
  720.     {
  721.         $this->work_handicapped = $work_handicapped;
  722.     }
  724.     /**
  725.      * @return
  726.      */
  727.     public function getPunctualSport()
  728.     {
  729.         return $this->punctual_sport;
  730.     }
  732.     /**
  733.      * @param $punctual_sport
  734.      */
  735.     public function setPunctualSport($punctual_sport): void
  736.     {
  737.         $this->punctual_sport = $punctual_sport;
  738.     }
  740.     /**
  741.      * @return mixed
  742.      */
  743.     public function getUpdatedDataConfirmedAt()
  744.     {
  745.         return $this->updatedDataConfirmedAt;
  746.     }
  748.     /**
  749.      * @param mixed $updatedDataConfirmedAt
  750.      */
  751.     public function setUpdatedDataConfirmedAt($updatedDataConfirmedAt): void
  752.     {
  753.         $this->updatedDataConfirmedAt = $updatedDataConfirmedAt;
  754.     }
  756.     public function getJob(): ?Job
  757.     {
  758.         return $this->job;
  759.     }
  761.     public function setJob(?Job $job): self
  762.     {
  763.         $this->job = $job;
  765.         return $this;
  766.     }
  768.     public function getIsContact(): ?bool
  769.     {
  770.         return $this->isContact;
  771.     }
  773.     public function setIsContact(?bool $isContact): self
  774.     {
  775.         $this->isContact = $isContact;
  777.         return $this;
  778.     }
  780.     /**
  781.      * @return mixed
  782.      */
  783.     public function getLastLoginAt()
  784.     {
  785.         return $this->lastLoginAt;
  786.     }
  788.     /**
  789.      * @param mixed $lastLoginAt
  790.      */
  791.     public function setLastLoginAt($lastLoginAt): void
  792.     {
  793.         $this->lastLoginAt = $lastLoginAt;
  794.     }
  796.     //    /**
  797. //     * @ORM\PrePersist
  798. //     * @ORM\PreUpdate
  799. //     */
  800. //    public function updatedTimestamps(): void
  801. //    {
  802. //        $this->setUpdatedDataConfirmedAt(new \DateTime());
  803. //    }
  804.     /**
  805.      * @return mixed
  806.      */
  807.     public function getKeycloakId()
  808.     {
  809.         return $this->keycloakId;
  810.     }
  812.     /**
  813.      * @param mixed $keycloakId
  814.      */
  815.     public function setKeycloakId($keycloakId): void
  816.     {
  817.         $this->keycloakId = $keycloakId;
  818.     }
  820.     public function getSite(): ?Site
  821.     {
  822.         return $this->site;
  823.     }
  825.     public function setSite(?Site $site): self
  826.     {
  827.         $this->site = $site;
  829.         return $this;
  830.     }
  832.     /**
  833.      * @return mixed
  834.      */
  835.     public function getAgreeTermsAt()
  836.     {
  837.         return $this->agreeTermsAt;
  838.     }
  840.     /**
  841.      * @param mixed $agreeTermsAt
  842.      */
  843.     public function setAgreeTermsAt($agreeTermsAt): void
  844.     {
  845.         $this->agreeTermsAt = $agreeTermsAt;
  846.     }
  848.     /**
  849.      * @return mixed
  850.      */
  851.     public function getAgreePrivateDataAt()
  852.     {
  853.         return $this->agreePrivateDataAt;
  854.     }
  856.     /**
  857.      * @param mixed $agreePrivateDataAt
  858.      */
  859.     public function setAgreePrivateDataAt($agreePrivateDataAt): void
  860.     {
  861.         $this->agreePrivateDataAt = $agreePrivateDataAt;
  862.     }
  863. }