src/Entity/User.php line 21

  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Mapped\Entity;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Gedmo\Mapping\Annotation as Gedmo;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\EquatableInterface;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Component\Validator\Constraints as Assert;
  15. /**
  16.  * @ORM\Entity()
  17.  * @ORM\Table(name="user")
  18.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  19.  * @UniqueEntity(fields="email", message="registracija.emailVecPostoji", groups={"registration"})
  20.  */
  21. class User extends Entity implements EquatableInterface,UserInterface,PasswordAuthenticatedUserInterface
  22. {
  23.     /**
  24.      * @ORM\Column(type="string", length=180, name="first_name", nullable=true)
  25.      * @Assert\NotBlank(groups={"registration", "update"})
  26.      * @Assert\Length(max="100", groups={"registration", "update"})
  27.      */
  28.     private $firstName;
  30.     /**
  31.      * @ORM\Column(type="string", length=180, name="last_name", nullable=true)
  32.      * @Assert\NotBlank(groups={"registration", "update"})
  33.      * @Assert\Length(max="100", groups={"registration", "update"})
  34.      */
  35.     private $lastName;
  37.     /**
  38.      * @ORM\Column(type="simple_array")
  39.      */
  40.     private $roles = [];
  42.     /**
  43.      * @var string The hashed password
  44.      * @ORM\Column(type="string" , nullable=false, name="password")
  45.      */
  46.     private $password;
  48.     /**
  49.      * @Assert\Length(max="4096", groups={"registration", "password-reset", "update"})
  50.      * @Assert\NotBlank(groups={"registration", "password-reset"})
  51.      */
  52.     private $plainPassword;
  54.     /**
  55.      * @ORM\Column(type="string", length=100, unique=true)
  56.      * @Assert\Email(groups={"registration"}, message = "registracija.neispravanEmail")
  57.      * @Assert\NotBlank(groups={"registration"})
  58.      * @Assert\Length(max="100", groups={"registration"})
  59.      */
  60.     private $email;
  62.     /**
  63.      * @Gedmo\Slug(fields={"email"})
  64.      * @ORM\Column(name="slug", length=128)
  65.      */
  66.     private $slug;
  68.     /**
  69.      * @var $token
  70.      * @ORM\Column(name="token", type="string", length=191, nullable=true)
  71.      */
  72.     private $token = null;
  74.     /**
  75.      * @var $registrationToken
  76.      * @ORM\Column(name="registration_token", type="string", length=191, nullable=true)
  77.      */
  78.     private $registrationToken = null;
  81.     /**
  82.      * @ORM\Column(name="menu_visibility", type="boolean")
  83.      */
  84.     private $menuVisibility = false;
  86.     /**
  87.      * @ORM\ManyToOne(targetEntity="App\Entity\City")
  88.      * @ORM\JoinColumn(name="city")
  89.      */
  90.     private $city;
  92.     /**
  93.      * @ORM\OneToMany(
  94.      *     targetEntity="App\Entity\NotificationSystem",
  95.      *     mappedBy="recipient",
  96.      *     fetch="EXTRA_LAZY",
  97.      *     orphanRemoval=true,
  98.      *     cascade={"persist"}
  99.      * )
  100.      */
  101.     private $notification;
  103.     /**
  104.      * @ORM\OneToMany(
  105.      *     targetEntity="App\Entity\TenderUser",
  106.      *     mappedBy="user",
  107.      *     fetch="EXTRA_LAZY",
  108.      *     orphanRemoval=true,
  109.      *     cascade={"persist"}
  110.      * )
  111.      */
  112.     private $tenderUser;
  114.     public function __construct()
  115.     {
  116.         $this->tenderUser = new ArrayCollection();
  117.     }
  119.     /**
  120.      * @return mixed
  121.      */
  122.     public function getFirstName()
  123.     {
  124.         return $this->firstName;
  125.     }
  127.     /**
  128.      * @param mixed $firstName
  129.      * @return User
  130.      */
  131.     public function setFirstName($firstName): self
  132.     {
  133.         $this->firstName = $firstName;
  135.         return $this;
  136.     }
  138.     /**
  139.      * @return mixed
  140.      */
  141.     public function getLastName()
  142.     {
  143.         return $this->lastName;
  144.     }
  146.     /**
  147.      * @param mixed $lastName
  148.      * @return User
  149.      */
  150.     public function setLastName($lastName): self
  151.     {
  152.         $this->lastName = $lastName;
  154.         return $this;
  155.     }
  157.     /**
  158.      * @return mixed
  159.      */
  160.     public function getSlug()
  161.     {
  162.         return $this->slug;
  163.     }
  165.     /**
  166.      * @param mixed $slug
  167.      * @return User
  168.      */
  169.     public function setSlug($slug): self
  170.     {
  171.         $this->slug = $slug;
  173.         return $this;
  174.     }
  176.     /**
  177.      * @return mixed
  178.      */
  179.     public function getPlainPassword()
  180.     {
  181.         return $this->plainPassword;
  182.     }
  184.     /**
  185.      * @param mixed $plainPassword
  186.      * @return User
  187.      */
  188.     public function setPlainPassword($plainPassword): self
  189.     {
  190.         $this->plainPassword = $plainPassword;
  192.         $this->password = null;
  194.         return $this;
  195.     }
  198.     public function getPassword(): ?string
  199.     {
  200.         return $this->password;
  201.     }
  203.     /**
  204.      * @param string $password
  205.      * @return User
  206.      */
  207.     public function setPassword(string $password): self
  208.     {
  209.         $this->password = $password;
  211.         return $this;
  212.     }
  214.     /**
  215.      * @return mixed
  216.      */
  217.     public function getEmail()
  218.     {
  219.         return $this->email;
  220.     }
  222.     /**
  223.      * @param mixed $email
  224.      * @return User
  225.      */
  226.     public function setEmail($email): self
  227.     {
  228.         $this->email = $email;
  230.         return $this;
  231.     }
  233.     public function getUsername()
  234.     {
  235.         return $this->email;
  236.     }
  238.     public function getRoles() :array
  239.     {
  240.         $roles = $this->roles;
  241.         // guarantee every user at least has ROLE_USER
  242.         $roles[] = 'ROLE_USER';
  244.         return array_unique($roles);
  245.     }
  247.     /**
  248.      * @param array $roles
  249.      * @return $this
  250.      */
  251.     public function setRoles(array $roles): self
  252.     {
  253.         $this->roles = $roles;
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return mixed
  260.      */
  261.     public function getToken()
  262.     {
  263.         return $this->token;
  264.     }
  266.     /**
  267.      * @param mixed $token
  268.      * @return User
  269.      */
  270.     public function setToken($token): self
  271.     {
  272.         $this->token = $token;
  274.         return $this;
  275.     }
  277.     /**
  278.      * @return mixed
  279.      */
  280.     public function getRegistrationToken()
  281.     {
  282.         return $this->registrationToken;
  283.     }
  285.     /**
  286.      * @param mixed $registrationToken
  287.      * @return User
  288.      */
  289.     public function setRegistrationToken($registrationToken): self
  290.     {
  291.         $this->registrationToken = $registrationToken;
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return string
  298.      */
  299.     public function getFullName(): string
  300.     {
  301.         return $this->getFirstName() . ' ' . $this->getLastName();
  302.     }
  304.     /**
  305.      * @return bool
  306.      */
  307.     public function isMenuVisibility(): bool
  308.     {
  309.         return $this->menuVisibility;
  310.     }
  312.     /**
  313.      * @param bool $menuVisibility
  314.      */
  315.     public function setMenuVisibility(bool $menuVisibility): void
  316.     {
  317.         $this->menuVisibility = $menuVisibility;
  318.     }
  320.     /**
  321.      * @return mixed
  322.      */
  323.     public function getNotification()
  324.     {
  325.         return $this->notification;
  326.     }
  328.     /**
  329.      * @param mixed $notification
  330.      */
  331.     public function setNotification($notification): void
  332.     {
  333.         $this->notification = $notification;
  334.     }
  336.     /**
  337.      * @return ArrayCollection
  338.      */
  339.     public function getTenderUser(): ArrayCollection
  340.     {
  341.         return $this->tenderUser;
  342.     }
  344.     /**
  345.      * @return mixed
  346.      */
  347.     public function getCity()
  348.     {
  349.         return $this->city;
  350.     }
  352.     /**
  353.      * @param mixed $city
  354.      */
  355.     public function setCity($city): void
  356.     {
  357.         $this->city = $city;
  358.     }
  360.     /**
  361.      * @return int
  362.      */
  363.     public function isNotificationsUnread()
  364.     {
  365.         /** @var NotificationSystem $n */
  366.         foreach ($this->getNotification() as $n) {
  367.             if (null === $n->getReadDate()) {
  368.                 return true;
  369.             }
  370.         }
  372.         return false;
  373.     }
  375.     /**
  376.      * @return bool|int
  377.      */
  378.     public function getReference()
  379.     {
  380.     }
  382.     public function getSalt(){}
  383.     public function eraseCredentials(){}
  385.     /**
  386.      * The equality comparison should neither be done by referential equality
  387.      * nor by comparing identities (i.e. getId() === getId()).
  388.      *
  389.      * However, you do not need to compare every attribute, but only those that
  390.      * are relevant for assessing whether re-authentication is required.
  391.      *
  392.      * Also implementation should consider that $user instance may implement
  393.      * the extended user interface `AdvancedUserInterface`.
  394.      *
  395.      * @param UserInterface $user
  396.      *
  397.      * @return bool
  398.      */
  399.     public function isEqualTo(UserInterface $user): bool
  400.     {
  401.         return $user->getPassword() === $this->getPassword();
  402.     }
  404.     /**
  405.      * @return string
  406.      */
  407.     public function getUserIdentifier():string
  408.     {
  409.         return $this->getUsername();
  410.     }
  411. }