src/Entity/User.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Symfony\Component\Validator\Constraints as Assert;
  8. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  13. /**
  14.  * @ORM\Entity(repositoryClass=UserRepository::class)
  15.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  16.  */
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     /**
  20.      * @ORM\Id
  21.      * @ORM\GeneratedValue
  22.      * @ORM\Column(type="integer")
  23.      */
  24.     private $id;
  26.     /**
  27.      * @ORM\Column(type="string", length=180, unique=true)
  28.      */
  29.     private $email;
  31.     /**
  32.      * @ORM\Column(type="json")
  33.      */
  34.     private $roles = [];
  36.     /**
  37.      * @Assert\NotBlank()
  38.      * @Assert\Length(max=4096)
  39.      */
  40.     private $plainPassword;
  42.     /**
  43.      * The below length depends on the "algorithm" you use for encoding
  44.      * the password, but this works well with bcrypt.
  45.      ** @var string The hashed password
  46.      * @ORM\Column(type="string", length=255)
  47.      */
  48.     private $password;
  50.     /**
  51.      * @ORM\OneToOne(targetEntity=Compte::class, inversedBy="user", cascade={"persist", "remove"})
  52.      * @ORM\JoinColumn(nullable=true)
  53.      */
  54.     private $compte;
  56.     /**
  57.      * @ORM\OneToOne(targetEntity=Client::class, inversedBy="user", cascade={"persist", "remove"})
  58.      * @ORM\JoinColumn(nullable=true)
  59.      */
  60.     private $client;
  62.     /**
  63.      * @ORM\Column(type="boolean", options={"default":"1"})
  64.      */
  65.     private $isFirstConnexion = true;    
  67.     public function __construct()
  68.     {
  69.         $this->roles = array('ROLE_USER');
  70.     }
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  77.     public function getEmail(): ?string
  78.     {
  79.         return $this->email;
  80.     }
  82.     public function setEmail(string $email): self
  83.     {
  84.         $this->email = $email;
  86.         return $this;
  87.     }
  89.     /**
  90.      * A visual identifier that represents this user.
  91.      *
  92.      * @see UserInterface
  93.      */
  94.     public function getUserIdentifier(): string
  95.     {
  96.         return (string) $this->email;
  97.     }
  99.     /**
  100.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  101.      */
  102.     public function getUsername(): string
  103.     {
  104.         return (string) $this->email;
  105.     }
  107.     /**
  108.      * @see UserInterface
  109.      */
  110.     public function getRoles(): array
  111.     {
  112.         $roles = $this->roles;
  113.         // guarantee every user at least has ROLE_USER
  114.         $roles[] = 'ROLE_USER';
  116.         return array_unique($roles);
  117.     }
  119.     public function setRoles(array $roles): self
  120.     {
  121.         $this->roles = $roles;
  123.         return $this;
  124.     }
  126.     public function getPlainPassword()
  127.     {
  128.         return $this->plainPassword;
  129.     }
  131.     public function setPlainPassword($password)
  132.     {
  133.         $this->plainPassword = $password;
  134.     }
  136.     /**
  137.      * @see PasswordAuthenticatedUserInterface
  138.      */
  139.     public function getPassword(): string
  140.     {
  141.         return $this->password;
  142.     }
  144.     public function setPassword(string $password): self
  145.     {
  146.         $this->password = $password;
  148.         return $this;
  149.     }
  151.     /**
  152.      * Returning a salt is only needed, if you are not using a modern
  153.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  154.      *
  155.      * @see UserInterface
  156.      */
  157.     public function getSalt(): ?string
  158.     {
  159.         return null;
  160.     }
  162.     /**
  163.      * @see UserInterface
  164.      */
  165.     public function eraseCredentials()
  166.     {
  167.         // If you store any temporary, sensitive data on the user, clear it here
  168.         // $this->plainPassword = null;
  169.     }
  171.     public function getCompte(): ?Compte
  172.     {
  173.         return $this->compte;
  174.     }
  176.     public function setCompte(Compte $compte): self
  177.     {
  179.         $this->compte = $compte;
  181.         return $this;
  182.     }
  184.     public function getClient(): ?Client
  185.     {
  186.         return $this->client;
  187.     }
  189.     public function setClient(Client $client): self
  190.     {
  192.         $this->client = $client;
  194.         return $this;
  195.     }
  197.     public function isIsFirstConnexion(): ?bool
  198.     {
  199.         return $this->isFirstConnexion;
  200.     }
  202.     public function setIsFirstConnexion(bool $isFirstConnexion): self
  203.     {
  204.         $this->isFirstConnexion = $isFirstConnexion;
  206.         return $this;
  207.     }    
  208. }