src/Admin/Entity/StdUsers.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Admin\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  10. use Symfony\Component\Validator\Constraints as Assert;
  11. /**
  12.  * StdUsers
  13.  */
  14. #[ORM\Table(name: 'std_users')]
  15. #[ORM\Index(name: 'fk_std_users_std_users', columns: ['created_by'])]
  16. #[ORM\Index(name: 'fk_std_users_std_users_upd', columns: ['updated_by'])]
  17. #[ORM\Entity(repositoryClass: 'App\Admin\Repository\StdUsersRepository')]
  18. #[ORM\HasLifecycleCallbacks]
  19. class StdUsers implements UserInterface/*, \Serializable*/, PasswordAuthenticatedUserInterface
  20. {
  21.     /**
  22.      * @var int
  23.      */
  24.     #[ORM\Column(name: 'id', type: 'integer', nullable: false, options: ['unsigned' => true, 'comment' => 'Unique identifier'])]
  25.     #[ORM\Id]
  26.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  27.     private $id;
  29.     /**
  30.      * @var string|null
  31.      */
  32.     #[ORM\Column(name: 'name', type: 'string', length: 255, nullable: true, options: ['comment' => "User's name"])]
  33.     private $name;
  35.     /**
  36.      * @var string
  37.      */
  38.     #[ORM\Column(name: 'username', type: 'string', length: 100, nullable: false, options: ['comment' => 'Username used to login'])]
  39.     private $username;
  41.     /**
  42.      * @var string
  43.      */
  44.     #[Assert\Email]
  45.     #[ORM\Column(name: 'email', type: 'string', length: 254, nullable: false, options: ['comment' => 'Email address of the user'])]
  46.     private $email;
  48.     /**
  49.      * @var string
  50.      */
  51.     #[ORM\Column(name: 'password', type: 'string', length: 255, nullable: false, options: ['comment' => "User's password"])]
  52.     private $password;
  54.     /**
  55.      * @var \DateTime|null
  56.      */
  57.     #[ORM\Column(name: 'password_date', type: 'datetime', nullable: true, options: ['comment' => 'Last date and time the password was updated'])]
  58.     private $passwordDate;
  60.     /**
  61.      * @var int|null
  62.      */
  63.     #[ORM\Column(name: 'failed_attempts', type: 'integer', nullable: true, options: ['unsigned' => true, 'comment' => 'Number of failed login attempts'])]
  64.     private $failedAttempts = '0';
  66.     /**
  67.      * @var bool|null
  68.      */
  69.     #[ORM\Column(name: 'force_password_change', type: 'boolean', nullable: true, options: ['comment' => 'Flag to force the user to change the password on the next login'])]
  70.     private $forcePasswordChange;
  72.     /**
  73.      * @var \DateTime|null
  74.      */
  75.     #[ORM\Column(name: 'last_login_date', type: 'datetime', nullable: true, options: ['comment' => 'Date and time of the last successful login'])]
  76.     private $lastLoginDate;
  78.     /**
  79.      * @var \DateTime|null
  80.      */
  81.     #[ORM\Column(name: 'penultimate_login_date', type: 'datetime', nullable: true, options: ['comment' => 'Date and time of the penultimate successful login'])]
  82.     private $penultimateLoginDate;
  84.     /**
  85.      * @var string|null
  86.      */
  87.     #[ORM\Column(name: 'language', type: 'string', length: 3, nullable: true, options: ['comment' => "Preferred user interface's language code"])]
  88.     private $language;
  90.     /**
  91.      * @var bool
  92.      */
  93.     #[ORM\Column(name: 'is_locked', type: 'boolean', nullable: false, options: ['comment' => 'Flag to lock the user'])]
  94.     private $isLocked = '0';
  96.     /**
  97.      * @var bool
  98.      */
  99.     #[ORM\Column(name: 'is_super_user', type: 'boolean', nullable: false, options: ['comment' => 'Flag indicating super user privileges'])]
  100.     private $isSuperUser = '0';
  102.     /**
  103.      * @var bool
  104.      */
  105.     #[ORM\Column(name: 'is_deleted', type: 'boolean', nullable: false, options: ['comment' => 'Flag that indicates the user has been deleted'])]
  106.     private $isDeleted = '0';
  108.     /**
  109.      * @var bool
  110.      */
  111.     #[ORM\Column(name: 'is_active', type: 'boolean', nullable: false, options: ['default' => 1, 'comment' => 'Flag that indicates if the user is active'])]
  112.     private $isActive = '1';
  114.     /**
  115.      * @var \DateTime
  116.      */
  117.     #[ORM\Column(name: 'created_date', type: 'datetime', nullable: false, options: ['comment' => 'Date and time of the record creation'])]
  118.     private $createdDate;
  120.     /**
  121.      * @var \DateTime
  122.      */
  123.     #[ORM\Column(name: 'updated_date', type: 'datetime', nullable: false, options: ['comment' => 'Date and time the record was last updated'])]
  124.     private $updatedDate;
  126.     /**
  127.      * @var \App\Admin\Entity\StdUsers
  128.      */
  129.     #[ORM\JoinColumn(name: 'created_by', referencedColumnName: 'id')]
  130.     #[ORM\ManyToOne(targetEntity: '\App\Admin\Entity\StdUsers')]
  131.     private $createdBy;
  133.     /**
  134.      * @var \App\Admin\Entity\StdUsers
  135.      */
  136.     #[ORM\JoinColumn(name: 'updated_by', referencedColumnName: 'id')]
  137.     #[ORM\ManyToOne(targetEntity: '\App\Admin\Entity\StdUsers')]
  138.     private $updatedBy;
  140.      /**
  141.      * @var Doctrine\Common\Collections\ArrayCollection|null
  142.      */
  143.     #[ORM\OneToMany(targetEntity: 'StdFavoritePagesUsers', mappedBy: 'userId', cascade: ['persist', 'remove'], orphanRemoval: true, fetch: 'EXTRA_LAZY')]
  144.     private $favoritePages;
  146.     #[ORM\ManyToMany(targetEntity: StdRoles::class, inversedBy: 'users')]
  147.     private Collection $userRoles;
  149.     /**
  150.      * @var Collection<int, StdPages>
  151.      */
  152.     #[ORM\ManyToMany(targetEntity: StdPages::class, mappedBy: 'pageAuthors')]
  153.     #[ORM\JoinTable(name: 'std_pages_authors')]
  154.     private Collection $authoredPages;
  156.     /**
  157.      * @var string|null
  158.      */
  159.     #[ORM\Column(name: 'author_function', type: 'string', length: 2048, nullable: true, options: ['comment' => 'User function/role when authoring pages'])]
  160.     private $authorFunction;
  162.     /**
  163.      * @var string|null
  164.      */
  165.     #[ORM\Column(name: 'user_image', type: 'string', length: 255, nullable: true, options: ['comment' => 'User avatar image'])]
  166.     private $userImage;
  168.     public function __construct()
  169.     {
  170.         $this->userRoles = new ArrayCollection();
  171.         $this->authoredPages = new ArrayCollection();
  172.     }
  174.     /**
  175.      * @param bool $firewallCall this must be true if used to validate user roles on Symfony's native code, otherwise it'll return a Collection and Symfony will be mad
  176.      * @return array|Collection<int, StdRoles> this will return either an array or a Collection, depending on how the parameter above is setup
  177.      */
  178.     public function getRoles(bool $firewallCall = true): array|Collection
  179.     {
  180.         if ($firewallCall) {
  181.             $roleArray = [];
  182.             foreach ($this->userRoles as $role) {
  183.                 if ($role->getIsActive()) {
  184.                     $roleArray[] = $role->getName();
  185.                 }
  186.             }
  188.             if (empty($roleArray)) {
  189.                 $roleArray[] = 'ROLE_ADMIN';
  190.             } 
  191.         } else {
  192.             $roleArray = $this->userRoles;
  193.         }
  195.         return $roleArray;
  196.     }
  198.     /**
  199.      * @return Collection<int, StdRoles> this will return a Collection
  200.      */
  201.     public function getUserRoles(): array|Collection
  202.     {
  203.         return $this->userRoles;
  204.     }
  206.     public function getId(): ?int
  207.     {
  208.         return $this->id;
  209.     }
  211.     public function getName(): ?string
  212.     {
  213.         return $this->name;
  214.     }
  216.     public function setName(?string $name): self
  217.     {
  218.         $this->name = $name;
  220.         return $this;
  221.     }
  223.     public function getUsername(): ?string
  224.     {
  225.         return $this->username;
  226.     }
  228.     public function getUserIdentifier(): string
  229.     {
  230.         return (string) $this->username;
  231.     }
  233.     public function setUsername(string $username): self
  234.     {
  235.         $this->username = $username;
  237.         return $this;
  238.     }
  240.     public function getEmail(): ?string
  241.     {
  242.         return $this->email;
  243.     }
  245.     public function setEmail(string $email): self
  246.     {
  247.         $this->email = $email;
  249.         return $this;
  250.     }
  252.     public function getPassword(): ?string
  253.     {
  254.         return $this->password;
  255.     }
  257.     public function setPassword(string $password): self
  258.     {
  259.         $this->password = $password;
  261.         return $this;
  262.     }
  264.     public function getPasswordDate(): ?\DateTimeInterface
  265.     {
  266.         return $this->passwordDate;
  267.     }
  269.     public function setPasswordDate(?\DateTimeInterface $passwordDate): self
  270.     {
  271.         $this->passwordDate = $passwordDate;
  273.         return $this;
  274.     }
  276.     public function getFailedAttempts(): ?int
  277.     {
  278.         return $this->failedAttempts;
  279.     }
  281.     public function setFailedAttempts(?int $failedAttempts): self
  282.     {
  283.         $this->failedAttempts = $failedAttempts;
  285.         return $this;
  286.     }
  288.     public function getForcePasswordChange(): ?bool
  289.     {
  290.         return $this->forcePasswordChange;
  291.     }
  293.     public function setForcePasswordChange(?bool $forcePasswordChange): self
  294.     {
  295.         $this->forcePasswordChange = $forcePasswordChange;
  297.         return $this;
  298.     }
  300.     public function getLastLoginDate(): ?\DateTimeInterface
  301.     {
  302.         return $this->lastLoginDate;
  303.     }
  305.     public function setLastLoginDate(?\DateTimeInterface $lastLoginDate): self
  306.     {
  307.         $this->lastLoginDate = $lastLoginDate;
  309.         return $this;
  310.     }
  312.     public function getPenultimateLoginDate(): ?\DateTimeInterface
  313.     {
  314.         return $this->penultimateLoginDate;
  315.     }
  317.     public function setPenultimateLoginDate(?\DateTimeInterface $penultimateLoginDate): self
  318.     {
  319.         $this->penultimateLoginDate = $penultimateLoginDate;
  321.         return $this;
  322.     }
  324.     public function getLanguage(): ?string
  325.     {
  326.         return $this->language;
  327.     }
  329.     public function setLanguage(?string $language): self
  330.     {
  331.         $this->language = $language;
  333.         return $this;
  334.     }
  336.     public function getIsLocked(): ?bool
  337.     {
  338.         return $this->isLocked;
  339.     }
  341.     public function setIsLocked(bool $isLocked): self
  342.     {
  343.         $this->isLocked = $isLocked;
  345.         return $this;
  346.     }
  348.     public function getIsSuperUser(): ?bool
  349.     {
  350.         return $this->isSuperUser;
  351.     }
  353.     public function setIsSuperUser(bool $isSuperUser): self
  354.     {
  355.         $this->isSuperUser = $isSuperUser;
  357.         return $this;
  358.     }
  360.     public function getIsDeleted(): ?bool
  361.     {
  362.         return $this->isDeleted;
  363.     }
  365.     public function setIsDeleted(bool $isDeleted): self
  366.     {
  367.         $this->isDeleted = $isDeleted;
  369.         return $this;
  370.     }
  372.     public function getIsActive(): ?bool
  373.     {
  374.         return $this->isActive;
  375.     }
  377.     public function setIsActive(bool $isActive): self
  378.     {
  379.         $this->isActive = $isActive;
  381.         return $this;
  382.     }
  384.     public function getCreatedDate(): ?\DateTimeInterface
  385.     {
  386.         return $this->createdDate;
  387.     }
  389.     public function setCreatedDate(\DateTimeInterface $createdDate): self
  390.     {
  391.         $this->createdDate = $createdDate;
  393.         return $this;
  394.     }
  396.     public function getUpdatedDate(): ?\DateTimeInterface
  397.     {
  398.         return $this->updatedDate;
  399.     }
  401.     public function setUpdatedDate(\DateTimeInterface $updatedDate): self
  402.     {
  403.         $this->updatedDate = $updatedDate;
  405.         return $this;
  406.     }
  408.     public function getCreatedBy(): ?\App\Admin\Entity\StdUsers
  409.     {
  410.         return $this->createdBy;
  411.     }
  413.     public function setCreatedBy(?self $createdBy): self
  414.     {
  415.         $this->createdBy = $createdBy;
  417.         return $this;
  418.     }
  420.     public function getUpdatedBy(): ?self
  421.     {
  422.         return $this->updatedBy;
  423.     }
  425.     public function setUpdatedBy(?self $updatedBy): self
  426.     {
  427.         $this->updatedBy = $updatedBy;
  429.         return $this;
  430.     }
  431.  
  432.     public function getSalt(): ?string
  433.     {
  434.         return null;
  435.     }
  437.     public function eraseCredentials()
  438.     {
  439.         // If you store any temporary, sensitive data on the user, clear it here
  440.         // $this->plainPassword = null;
  441.     }
  443.     #[ORM\PreUpdate]
  444.     public function setUpdated()
  445.     {
  446.         $this->setUpdatedDate(new \DateTime());
  447.     }
  449.     #[ORM\PrePersist]
  450.     public function setCreated()
  451.     {
  452.         $this->setUpdatedDate(new \DateTime());
  453.         $this->setCreatedDate(new \DateTime());
  454.     }
  457.     /**
  458.      * Get the value of favoritePage
  459.      *
  460.      * @return  object
  461.      */ 
  462.     public function getFavoritePage()
  463.     {
  464.         return $this->favoritePages;
  465.     }
  467.     /**
  468.      * Set the value of favoritePage
  469.      *
  470.      * @param  Page  $favoritePage
  471.      *
  472.      * @return  self
  473.      */ 
  474.     public function setFavoritePage(object $favoritePage)
  475.     {
  476.         $this->favoritePages = $favoritePage;
  478.         return $this;
  479.     }
  481.     /** Function serialize is here to solve "Notice: unserialize(): Error at offset" on php version 7.3 */
  482.     /*public function serialize()
  483.     {
  484.         list($major, $minor, $release) = explode(".", phpversion());
  485.         $vars = get_object_vars($this);
  486.         if ($major == 7 && $minor == 3)
  487.         {
  488.             unset($vars["createdBy"]);
  489.             unset($vars["updatedBy"]);
  490.             unset($vars["favoritePages"]);
  491.         }
  492.         return serialize($vars);
  493.     }*/
  495.     /** Function unserialize is here to solve "Notice: unserialize(): Error at offset" on php version 7.3 */
  496.     /*public function unserialize($data)
  497.     {
  498.         $vars = unserialize($data);
  499.         foreach ($vars as $key => $value)
  500.         {
  501.             $this->$key = $value;
  502.         }
  503.     }*/
  505.     public function addUserRole(StdRoles $role): static
  506.     {
  507.         if (!$this->userRoles->contains($role)) {
  508.             $this->userRoles->add($role);
  509.         }
  511.         return $this;
  512.     }
  514.     public function removeUserRole(StdRoles $role): static
  515.     {
  516.         $this->userRoles->removeElement($role);
  518.         return $this;
  519.     }
  521.     public function isSuperAdmin(): bool
  522.     {
  523.         foreach ($this->getRoles() as $role) {
  524.             if ($role === "ROLE_SUPER_ADMIN") {
  525.                 return true;
  526.             }
  527.         }
  528.         return false;
  529.     }
  531.     /**
  532.      * @return Collection<int, StdPages>
  533.      */
  534.     public function getAuthoredPages(): Collection
  535.     {
  536.         return $this->authoredPages;
  537.     }
  539.     public function addAuthoredPage(StdPages $page): self
  540.     {
  541.         if (!$this->authoredPages->contains($page)) {
  542.             $this->authoredPages->add($page);
  543.         }
  544.         return $this;
  545.     }
  547.     public function removeAuthoredPage(StdPages $page): self
  548.     {
  549.         $this->authoredPages->removeElement($page);
  550.         return $this;
  551.     }
  553.     public function getAuthorFunction(): ?string
  554.     {
  555.         return $this->authorFunction;
  556.     }
  558.     public function setAuthorFunction(?string $authorFunction): self
  559.     {
  560.         $this->authorFunction = $authorFunction;
  561.         return $this;
  562.     }
  564.     public function getUserImage(): ?string
  565.     {
  566.         return $this->userImage;
  567.     }
  569.     public function setUserImage(?string $userImage): self
  570.     {
  571.         $this->userImage = $userImage;
  572.         return $this;
  573.     }
  574. }