src/Entity/User.php line 34

Open in your IDE?
  1. <?php
  3. /*
  4.  * This event is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * event that was distributed with this source code.
  10.  */
  12. namespace App\Entity;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use Doctrine\Common\Collections\ArrayCollection;
  16. use Doctrine\Common\Collections\Collection;
  17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Validator\Constraints as Assert;
  21. /**
  22.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  23.  * @ORM\Table(name="user")
  24.  *
  25.  * Defines the properties of the User entity to represent the application users.
  26.  * See https://symfony.com/doc/current/doctrine.html#creating-an-entity-class
  27.  *
  28.  * Tip: if you have an existing database, you can generate these entity class automatically.
  29.  * See https://symfony.com/doc/current/doctrine/reverse_engineering.html
  30.  *
  31.  * @author Ryan Weaver <weaverryan@gmail.com>
  32.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  33.  */
  34. class User implements UserInterface, PasswordAuthenticatedUserInterface {
  36.     /**
  37.      * @ORM\Id
  38.      * @ORM\GeneratedValue
  39.      * @ORM\Column(type="integer")
  40.      */
  41.     private ?int $id = null;
  43.     /**
  44.      * @ORM\Column(type="string")
  45.      */
  46.     #[Assert\NotBlank]
  47.     private ?string $firstname = null;
  48.     
  49.     /**
  50.      * @ORM\Column(type="string")
  51.      */
  52.     #[Assert\NotBlank]
  53.     private ?string $lastname = null;
  55.     /**
  56.      * @ORM\Column(type="string", unique=true)
  57.      */
  58.     #[
  59.         Assert\NotBlank,
  60.         Assert\Length(min: 2, max: 50)
  61.     ]
  62.     private ?string $username = null;
  64.     /**
  65.      * @ORM\Column(type="string", nullable=true)
  66.      */
  67.     private ?string $published = "1";
  68.     
  69.     /**
  70.      * @ORM\Column(type="string", nullable=true)
  71.      */
  72.     private ?string $bio;
  74.     /**
  75.      * @ORM\Column(type="datetime", nullable=true)
  76.      */
  77.     private \DateTime $createdAt;
  79.     /**
  80.      * @ORM\Column(type="string", nullable=true)
  81.      */
  82.     private ?string $emailVerification = "0";
  84.     /**
  85.      * @ORM\Column(type="string", unique=true)
  86.      */
  87.     #[Assert\Email]
  88.     private ?string $email = null;
  90.     /**
  91.      * @ORM\Column(type="string", nullable=true)
  92.      */
  93.     private ?string $password = null;
  95.     /**
  96.      * @ORM\Column(type="string", nullable=true)
  97.      */
  98.     private ?string $tokenreset = null;
  100.     /**
  101.      * @ORM\Column(type="string", nullable=true)
  102.      */
  103.     private ?string $phone = null;
  105.     /**
  106.      * @ORM\Column(type="string", nullable=true)
  107.      */
  108.     private ?string $country = null;
  109.     
  110.     /**
  111.      * @ORM\Column(type="string", nullable=true)
  112.      */
  113.     private ?string $gender = null;
  114. //    1 men 0 women
  115.     
  116.     /**
  117.      * @ORM\Column(type="string", nullable=true)
  118.      */
  119.     private ?string $address = null;
  121.     /**
  122.      * @ORM\Column(type="json")
  123.      */
  124.     private array $roles = [];
  126.     
  128.     /**
  129.      * @ORM\Column(type="string", nullable=true)
  130.      */
  131.     private ?string $image = null;
  133.     public function __construct() {
  134.         $this->createdAt = new \DateTime('now');
  135.     }
  137.     public function getId(): ?int {
  138.         return $this->id;
  139.     }
  141.     public function setFullName(string $fullName): void {
  142.         $this->fullName = $fullName;
  143.     }
  145.     public function getFullName(): ?string {
  146.         return $this->fullName;
  147.     }
  149.     public function getUserIdentifier(): string {
  150.         return $this->username;
  151.     }
  153.     public function getFirstname(): ?string {
  154.         return $this->firstname;
  155.     }
  157.     public function getLastname(): ?string {
  158.         return $this->lastname;
  159.     }
  161.     public function getUsername(): ?string {
  162.         return $this->username;
  163.     }
  166.     public function getBio(): ?string {
  167.         return $this->bio;
  168.     }
  170.     public function getEmail(): ?string {
  171.         return $this->email;
  172.     }
  174.     public function getPassword(): ?string {
  175.         return $this->password;
  176.     }
  178.     public function setFirstname(?string $firstname): void {
  179.         $this->firstname = $firstname;
  180.     }
  182.     public function setLastname(?string $lastname): void {
  183.         $this->lastname = $lastname;
  184.     }
  186.     public function setUsername(?string $username): void {
  187.         $this->username = $username;
  188.     }
  190.     public function getPublished(): ?string {
  191.         return $this->published;
  192.     }
  194.     public function setPublished(?string $published): void {
  195.         $this->published = $published;
  196.     }
  198.         public function setBio(?string $bio): void {
  199.         $this->bio = $bio;
  200.     }
  202.     public function setEmail(?string $email): void {
  203.         $this->email = $email;
  204.     }
  206.     public function setPassword(?string $password): void {
  207.         $this->password = $password;
  208.     }
  210.     
  211.     /**
  212.      * Returns the roles or permissions granted to the user for security.
  213.      */
  214.     public function getRoles(): array {
  215.         $roles = $this->roles;
  217.         // guarantees that a user always has at least one role for security
  218.         if (empty($roles)) {
  219.             $roles[] = 'ROLE_USER';
  220.         }
  222.         return array_unique($roles);
  223.     }
  225.     public function setRoles(array $roles): void {
  226.         $this->roles = $roles;
  227.     }
  229.     public function getTokenreset(): ?string {
  230.         return $this->tokenreset;
  231.     }
  233.     public function setTokenreset(?string $tokenreset): void {
  234.         $this->tokenreset = $tokenreset;
  235.     }
  237.     public function getEmailVerification(): ?string {
  238.         return $this->emailVerification;
  239.     }
  241.     public function setEmailVerification(?string $emailVerification): void {
  242.         $this->emailVerification = $emailVerification;
  243.     }
  245.     public function getPhone(): ?string {
  246.         return $this->phone;
  247.     }
  249.     public function setPhone(?string $phone): void {
  250.         $this->phone = $phone;
  251.     }
  253.     public function getCreatedAt(): \DateTime {
  254.         return $this->createdAt;
  255.     }
  257.     public function setCreatedAt(\DateTime $createdAt): void {
  258.         $this->createdAt = $createdAt;
  259.     }
  261.         
  262.     /**
  263.      * Returns the salt that was originally used to encode the password.
  264.      *
  265.      * {@inheritdoc}
  266.      */
  267.     public function getSalt(): ?string {
  268.         // We're using bcrypt in security.yaml to encode the password, so
  269.         // the salt value is built-in and you don't have to generate one
  270.         // See https://en.wikipedia.org/wiki/Bcrypt
  272.         return null;
  273.     }
  275.     /**
  276.      * Removes sensitive data from the user.
  277.      *
  278.      * {@inheritdoc}
  279.      */
  280.     public function eraseCredentials(): void {
  281.         // if you had a plainPassword property, you'd nullify it here
  282.         // $this->plainPassword = null;
  283.     }
  285.     public function __serialize(): array {
  286.         // add $this->salt too if you don't use Bcrypt or Argon2i
  287.         return [$this->id, $this->username, $this->password];
  288.     }
  290.     public function __unserialize(array $data): void {
  291.         // add $this->salt too if you don't use Bcrypt or Argon2i
  292.         [$this->id, $this->username, $this->password] = $data;
  293.     }
  294.     public function getImage(): ?string {
  295.         return $this->image;
  296.     }
  298.     public function setImage(?string $image): void {
  299.         $this->image = $image;
  300.     }
  301.     public function getCountry(): ?string {
  302.         return $this->country;
  303.     }
  305.     public function getAddress(): ?string {
  306.         return $this->address;
  307.     }
  309.     public function setCountry(?string $country): void {
  310.         $this->country = $country;
  311.     }
  313.     public function setAddress(?string $address): void {
  314.         $this->address = $address;
  315.     }
  317.     public function getGender(): ?string {
  318.         return $this->gender;
  319.     }
  321.     public function setGender(?string $gender): void {
  322.         $this->gender = $gender;
  323.     }
  325. }