src/Entity/User.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Common\RoleInterface;
  6. use App\Entity\Traits\BaseDateAtTrait;
  7. use App\Repository\UserRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Validator\Constraints as Assert;
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. #[ORM\HasLifecycleCallbacks]
  18. #[UniqueEntity('email')]
  19. class User implements UserInterface, RoleInterface, PasswordAuthenticatedUserInterface
  20. {
  21.     use BaseDateAtTrait;
  23.     // The list of civility
  24.     public const CIVILITY_MISSIS = 1;
  25.     public const CIVILITY_MISTER = 2;
  27.     // Full list
  28.     public const CIVILITY_LIST = [
  29.         self::CIVILITY_MISSIS => 'app.user.label.missis',
  30.         self::CIVILITY_MISTER => 'app.user.label.mister',
  31.     ];
  32.     
  33.     public const BINDINGS = [
  34.         '[[USER.FULLNAME]]',
  35.         '[[USER.NAME]]',
  36.         '[[USER.EMAIL]]',
  37.         '[[USER.STATUS]]',
  38.         '[[USER.UNIVERSITY]]',
  39.         '[[USER.ADMIN.REVIEW]]',
  40.     ];
  42.     #[ORM\Id]
  43.     #[ORM\GeneratedValue]
  44.     #[ORM\Column(type: 'integer')]
  45.     private $id;
  47.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  48.     private $username;
  50.     #[ORM\Column(type: 'json')]
  51.     private $roles = [];
  53.     /**
  54.      * @var string The hashed password
  55.      */
  56.     #[ORM\Column(type: 'string')]
  57.     private $password;
  59.     #[Assert\NotBlank(groups: ['ResetPassword', 'Registration', 'ChangePassword', 'AccountChangePassword'])]
  60.     #[Assert\Length(min: 8, max: 4096, minMessage: 'app.user.password.length', groups: ['Profile', 'ResetPassword', 'Registration', 'ChangePassword', 'AccountChangePassword'])]
  61.     #[Assert\Regex(pattern: '/^([^0-9]*|[^A-Z]*|[a-zA-Z0-9]*)$/', message: 'app.user.password.rule', match: false, groups: ['Profile', 'ResetPassword', 'Registration', 'ChangePassword', 'AccountChangePassword'])]
  62.     protected $plainPassword;
  64.     #[ORM\Column(type: 'smallint', nullable: true)]
  65.     private $civility;
  67.     #[ORM\Column(type: 'string', length: 255)]
  68.     private $firstName;
  70.     #[ORM\Column(type: 'string', length: 255)]
  71.     private $lastName;
  73.     #[ORM\Column(type: 'string', length: 255, unique: true)]
  74.     private $email;
  76.     #[ORM\Column(type: 'string', length: 255, unique: true)]
  77.     private $uuid;
  79.     #[ORM\Column(type: 'datetime', nullable: true)]
  80.     private $lastLogin;
  82.     #[ORM\OneToMany(targetEntity: PersonalResource::class, mappedBy: 'user', cascade: ['remove'])]
  83.     private $personalResources;
  85.     #[ORM\OneToMany(targetEntity: UserProject::class, mappedBy: 'user', cascade: ['remove'])]
  86.     private $userProjects;
  88.     #[ORM\OneToMany(targetEntity: UserWorkroom::class, mappedBy: 'user', cascade: ['remove'])]
  89.     private $userWorkrooms;
  91.     #[ORM\OneToMany(targetEntity: ReadingCard::class, mappedBy: 'user')]
  92.     private $readingCards;
  94.     #[ORM\OneToMany(targetEntity: ReadingCard::class, mappedBy: 'lastUser')]
  95.     private $lastUserReadingCards;
  97.     #[ORM\ManyToOne(targetEntity: University::class, inversedBy: 'users')]
  98.     private $university;
  100.     #[ORM\OneToOne(targetEntity: UserProfile::class, mappedBy: 'user', cascade: ['persist', 'remove'])]
  101.     private $userProfile;
  103.     #[ORM\OneToMany(targetEntity: PersonalFolder::class, mappedBy: 'user', cascade: ['remove'])]
  104.     private $personalFolders;
  106.     #[ORM\OneToOne(targetEntity: ResetPasswordToken::class, mappedBy: 'User', cascade: ['persist','remove'])]
  107.     private $resetPasswordToken;
  109.     #[ORM\Column(type: 'boolean', options: ['default' => 0])]
  110.     private $isActive;
  112.     #[ORM\ManyToOne(targetEntity: Statut::class)]
  113.     private $statut;
  115.     #[ORM\OneToMany(targetEntity: Notification::class, mappedBy: 'user', cascade: ['persist', 'remove'])]
  116.     private $notifications;
  118.     #[ORM\Column(type: 'string', length: 500, nullable: true)]
  119.     private $adminReview;
  121.     #[ORM\Column(type: 'boolean', options: ['default' => 0])]
  122.     private $isDisabled;
  124.     #[ORM\OneToMany(targetEntity: SectionRevision::class, mappedBy: 'user', cascade: ['persist'])]
  125.     private $sectionRevisions;
  127.     #[ORM\OneToMany(targetEntity: WorkroomRevision::class, mappedBy: 'user')]
  128.     private $workroomRevisions;
  130.     #[ORM\OneToMany(targetEntity: UserWorkroomArena::class, mappedBy: 'user', orphanRemoval: true, cascade: ['remove'])]
  131.     private $userWorkroomArenas;
  133.     #[ORM\OneToMany(targetEntity: SearchQuery::class, mappedBy: 'user', orphanRemoval: true, cascade: ['remove'])]
  134.     private $searchQueries;
  136.     #[ORM\OneToMany(targetEntity: History::class, mappedBy: 'user', orphanRemoval: true, cascade: ['remove'])]
  137.     private $histories;
  139.     #[ORM\OneToMany(targetEntity: HistoryEvent::class, mappedBy: 'User', orphanRemoval: true, cascade: ['remove'])]
  140.     private $historyEvents;
  142.     #[ORM\ManyToOne(inversedBy: 'users')]
  143.     private ?Organization $organization = null;
  145.     #[ORM\Column(type: 'string', length: 180, nullable: true, unique: true)]
  146.     private $zoteroUserId;
  148.     #[ORM\Column(type: 'string', length: 255, nullable: true, unique: true)]
  149.     private $zoteroApiKey;
  151.     /** Clé API Semantic Scholar par utilisateur (https://www.semanticscholar.org/product/api). */
  152.     #[ORM\Column(type: 'string', length: 255, nullable: true, name: 'semantic_scholar_api_key')]
  153.     private ?string $semanticScholarApiKey = null;
  155.     #[ORM\Column(nullable: true)]
  156.     private ?string $twoFactorCode = null;
  158.     #[ORM\Column(type: 'datetime', nullable: true)]
  159.     private ?\DateTimeInterface $twoFactorExpiresAt = null;
  161.     #[ORM\Column(type: 'boolean')]
  162.     private bool $isTwoFactorEnabled = false;
  164.     /**
  165.      * User constructor.
  166.      */
  167.     public function __construct()
  168.     {
  169.         $this->personalResources = new ArrayCollection();
  170.         $this->userProjects = new ArrayCollection();
  171.         $this->userWorkrooms = new ArrayCollection();
  172.         $this->readingCards = new ArrayCollection();
  173.         $this->personalFolders = new ArrayCollection();
  174.         $this->isActive = $this->isDisabled = false;
  175.         $this->notifications = new ArrayCollection();
  176.         $this->workroomRevisions = new ArrayCollection();
  177.         $this->userWorkroomArenas = new ArrayCollection();
  178.         $this->searchQueries = new ArrayCollection();
  179.         $this->histories = new ArrayCollection();
  180.         $this->historyEvents = new ArrayCollection();
  181.     }
  183.     /**
  184.      * @return string
  185.      */
  186.     public function __toString()
  187.     {
  188.         return $this->firstName.' '.$this->lastName;
  189.     }
  190.     
  191.     public function getBindings(): array
  192.     {
  193.         return [
  194.             'USER.FULLNAME' => $this->getFullName(),
  195.             'USER.NAME' => strtoupper($this->getLastName()),
  196.             'USER.EMAIL' => $this->getEmail(),
  197.             'USER.STATUS' => $this->getStatut(),
  198.             'USER.UNIVERSITY' => $this->getOrganization(),
  199.             'USER.ORGANIZATION' => $this->getOrganization(),
  200.             'USER.ADMIN.REVIEW' => $this->getAdminReview()
  201.         ];
  202.     }
  204.     public function getFullName(): string
  205.     {
  206.         return $this->firstName.' '.strtoupper($this->lastName);
  207.     }
  209.     public function activate()
  210.     {
  211.         $this->setIsActive(true);
  212.         $this->addRole(RoleInterface::ROLE_USER);
  213.     }
  215.     /**
  216.      * Gets triggered only on insert.
  217.      * Set created date.
  218.      */
  219.     #[ORM\PrePersist]
  220.     public function onPrePersist()
  221.     {
  222.         $this->generateUuid();
  224.         return $this;
  225.     }
  227.     public function getId(): ?int
  228.     {
  229.         return $this->id;
  230.     }
  232.     public function isItAdmin(): bool
  233.     {
  234.         if (!empty(array_intersect(RoleInterface::ROLE_ADMINS, $this->roles))) {
  235.             return true;
  236.         }
  238.         return false;
  239.     }
  241.     public function hasRoles(array $roles): bool
  242.     {
  243.         if (!empty(array_intersect($roles, $this->roles))) {
  244.             return true;
  245.         }
  247.         return false;
  248.     }
  250.     /**
  251.      * A visual identifier that represents this user.
  252.      *
  253.      * @see UserInterface
  254.      */
  255.     public function getUsername(): string
  256.     {
  257.         return (string) $this->username;
  258.     }
  260.     /**
  261.      * @return $this
  262.      */
  263.     public function setUsername(string $username): self
  264.     {
  265.         $this->username = $username;
  267.         return $this;
  268.     }
  270.     /**
  271.      * @see UserInterface
  272.      */
  273.     public function getRoles(): array
  274.     {
  275.         $roles = $this->roles;
  277.         // guarantee every user at least has ROLE_USER
  278.         $roles[] = 'ROLE_USER';
  280.         return array_unique($roles);
  281.     }
  283.     public function addRole(string $role): User
  284.     {
  285.         if (!in_array($role, $this->roles)) {
  286.             $this->roles[] = $role;
  287.         }
  289.         return $this;
  290.     }
  292.     /**
  293.      * @return $this
  294.      */
  295.     public function setRoles(array $roles): self
  296.     {
  297.         $this->roles = $roles;
  299.         return $this;
  300.     }
  302.     public function hasRole(string $role): bool
  303.     {
  304.         return false !== array_search($role, $this->getRoles());
  305.     }
  307.     /**
  308.      * @see UserInterface
  309.      */
  310.     public function getPassword(): string
  311.     {
  312.         return (string) $this->password;
  313.     }
  315.     /**
  316.      * @return $this
  317.      */
  318.     public function setPassword(string $password): self
  319.     {
  320.         $this->password = $password;
  322.         return $this;
  323.     }
  325.     /**
  326.      * Returning a salt is only needed, if you are not using a modern
  327.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  328.      *
  329.      * @see UserInterface
  330.      */
  331.     public function getSalt(): ?string
  332.     {
  333.         return null;
  334.     }
  336.     /**
  337.      * @see UserInterface
  338.      */
  339.     public function eraseCredentials()
  340.     {
  341.         $this->plainPassword = null;
  342.     }
  344.     public function getCivility(): ?int
  345.     {
  346.         return $this->civility;
  347.     }
  349.     /**
  350.      * @return $this
  351.      */
  352.     public function setCivility(?int $civility): self
  353.     {
  354.         $this->civility = $civility;
  356.         return $this;
  357.     }
  359.     /**
  360.      * Provide the name of civility bases on key value.
  361.      */
  362.     public function getCivilityName(): string
  363.     {
  364.         return self::CIVILITY_LIST[$this->civility] ?? '';
  365.     }
  367.     public function getFirstName(): ?string
  368.     {
  369.         return $this->firstName;
  370.     }
  372.     /**
  373.      * @return $this
  374.      */
  375.     public function setFirstName(string $firstName): self
  376.     {
  377.         $this->firstName = $firstName;
  379.         return $this;
  380.     }
  382.     public function getLastName(): ?string
  383.     {
  384.         return $this->lastName;
  385.     }
  387.     /**
  388.      * @return $this
  389.      */
  390.     public function setLastName(string $lastName): self
  391.     {
  392.         $this->lastName = $lastName;
  394.         return $this;
  395.     }
  397.     public function getEmail(): ?string
  398.     {
  399.         return $this->email;
  400.     }
  402.     /**
  403.      * @return $this
  404.      */
  405.     public function setEmail(string $email): self
  406.     {
  407.         $this->email = $email;
  409.         return $this;
  410.     }
  412.     public function getUuid(): ?string
  413.     {
  414.         return $this->uuid;
  415.     }
  417.     /**
  418.      * @return $this
  419.      */
  420.     public function setUuid(string $uuid): self
  421.     {
  422.         $this->uuid = $uuid;
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return $this
  429.      *
  430.      * @throws \Exception
  431.      */
  432.     public function generateUuid(): self
  433.     {
  434.         $this->uuid = bin2hex(random_bytes(16));
  436.         return $this;
  437.     }
  439.     public function getLastLogin(): ?\DateTimeInterface
  440.     {
  441.         return $this->lastLogin;
  442.     }
  444.     /**
  445.      * @return $this
  446.      */
  447.     public function setLastLogin(?\DateTimeInterface $lastLogin): self
  448.     {
  449.         $this->lastLogin = $lastLogin;
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection|PersonalResource[]
  456.      */
  457.     public function getPersonalResources(): Collection
  458.     {
  459.         return $this->personalResources;
  460.     }
  462.     /**
  463.      * @return $this
  464.      */
  465.     public function addPersonalResource(PersonalResource $personalResource): self
  466.     {
  467.         if (!$this->personalResources->contains($personalResource)) {
  468.             $this->personalResources[] = $personalResource;
  469.             $personalResource->setUser($this);
  470.         }
  472.         return $this;
  473.     }
  475.     /**
  476.      * @return $this
  477.      */
  478.     public function removePersonalResource(PersonalResource $personalResource): self
  479.     {
  480.         if ($this->personalResources->removeElement($personalResource)) {
  481.             // set the owning side to null (unless already changed)
  482.             if ($personalResource->getUser() === $this) {
  483.                 $personalResource->setUser(null);
  484.             }
  485.         }
  487.         return $this;
  488.     }
  490.     /**
  491.      * @return Collection|UserProject[]
  492.      */
  493.     public function getUserProjects(): Collection
  494.     {
  495.         return $this->userProjects;
  496.     }
  498.     public function addUserProject(UserProject $userProject): self
  499.     {
  500.         if (!$this->userProjects->contains($userProject)) {
  501.             $this->userProjects[] = $userProject;
  502.             $userProject->setUser($this);
  503.         }
  505.         return $this;
  506.     }
  508.     public function removeUserProject(UserProject $userProject): self
  509.     {
  510.         if ($this->userProjects->removeElement($userProject)) {
  511.             // set the owning side to null (unless already changed)
  512.             if ($userProject->getUser() === $this) {
  513.                 $userProject->setUser(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection|UserWorkroom[]
  522.      */
  523.     public function getUserWorkrooms(): Collection
  524.     {
  525.         return $this->userWorkrooms;
  526.     }
  528.     public function addUserWorkroom(UserWorkroom $userWorkroom): self
  529.     {
  530.         if (!$this->userWorkrooms->contains($userWorkroom)) {
  531.             $this->userWorkrooms[] = $userWorkroom;
  532.             $userWorkroom->setUser($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeUserWorkroom(UserWorkroom $userWorkroom): self
  539.     {
  540.         if ($this->userWorkrooms->removeElement($userWorkroom)) {
  541.             // set the owning side to null (unless already changed)
  542.             if ($userWorkroom->getUser() === $this) {
  543.                 $userWorkroom->setUser(null);
  544.             }
  545.         }
  547.         return $this;
  548.     }
  550.     /**
  551.      * @return Collection|ReadingCard[]
  552.      */
  553.     public function getReadingCards(): Collection
  554.     {
  555.         return $this->readingCards;
  556.     }
  558.     public function addReadingCard(ReadingCard $readingCard): self
  559.     {
  560.         if (!$this->readingCards->contains($readingCard)) {
  561.             $this->readingCards[] = $readingCard;
  562.             $readingCard->setUser($this);
  563.         }
  565.         return $this;
  566.     }
  568.     public function removeReadingCard(ReadingCard $readingCard): self
  569.     {
  570.         if ($this->readingCards->removeElement($readingCard)) {
  571.             // set the owning side to null (unless already changed)
  572.             if ($readingCard->getUser() === $this) {
  573.                 $readingCard->setUser(null);
  574.             }
  575.         }
  577.         return $this;
  578.     }
  580.     public function getUniversity(): ?University
  581.     {
  582.         return $this->university;
  583.     }
  585.     public function setUniversity(?University $university): self
  586.     {
  587.         $this->university = $university;
  589.         return $this;
  590.     }
  592.     public function getUserProfile(): ?UserProfile
  593.     {
  594.         return $this->userProfile;
  595.     }
  597.     public function setUserProfile(UserProfile $userProfile): self
  598.     {
  599.         // set the owning side of the relation if necessary
  600.         if ($userProfile->getUser() !== $this) {
  601.             $userProfile->setUser($this);
  602.         }
  604.         $this->userProfile = $userProfile;
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection|PersonalFolder[]
  611.      */
  612.     public function getPersonalFolders(): Collection
  613.     {
  614.         return $this->personalFolders;
  615.     }
  617.     public function addPersonalFolder(PersonalFolder $personalFolder): self
  618.     {
  619.         if (!$this->personalFolders->contains($personalFolder)) {
  620.             $this->personalFolders[] = $personalFolder;
  621.             $personalFolder->setUser($this);
  622.         }
  624.         return $this;
  625.     }
  627.     public function removePersonalFolder(PersonalFolder $personalFolder): self
  628.     {
  629.         if ($this->personalFolders->removeElement($personalFolder)) {
  630.             // set the owning side to null (unless already changed)
  631.             if ($personalFolder->getUser() === $this) {
  632.                 $personalFolder->setUser(null);
  633.             }
  634.         }
  636.         return $this;
  637.     }
  639.     public function getResetPasswordToken(): ?ResetPasswordToken
  640.     {
  641.         return $this->resetPasswordToken;
  642.     }
  644.     public function setResetPasswordToken(ResetPasswordToken $resetPasswordToken): self
  645.     {
  646.         // set the owning side of the relation if necessary
  647.         if ($resetPasswordToken->getUser() !== $this) {
  648.             $resetPasswordToken->setUser($this);
  649.         }
  651.         $this->resetPasswordToken = $resetPasswordToken;
  653.         return $this;
  654.     }
  656.     public function isActive(): ?bool
  657.     {
  658.         return $this->isActive;
  659.     }
  661.     public function setIsActive(bool $isActive): self
  662.     {
  663.         $this->isActive = $isActive;
  665.         return $this;
  666.     }
  668.     public function getStatut(): ?Statut
  669.     {
  670.         return $this->statut;
  671.     }
  673.     public function setStatut(?Statut $statut): self
  674.     {
  675.         $this->statut = $statut;
  677.         return $this;
  678.     }
  680.     /**
  681.      * @return Collection|Notification[]
  682.      */
  683.     public function getNotifications(): Collection
  684.     {
  685.         return $this->notifications;
  686.     }
  688.     public function addNotification(Notification $notification): self
  689.     {
  690.         if (!$this->notifications->contains($notification)) {
  691.             $this->notifications[] = $notification;
  692.             $notification->setUser($this);
  693.         }
  695.         return $this;
  696.     }
  698.     public function removeNotification(Notification $notification): self
  699.     {
  700.         if ($this->notifications->removeElement($notification)) {
  701.             // set the owning side to null (unless already changed)
  702.             if ($notification->getUser() === $this) {
  703.                 $notification->setUser(null);
  704.             }
  705.         }
  707.         return $this;
  708.     }
  710.     public function getAdminReview(): ?string
  711.     {
  712.         return $this->adminReview;
  713.     }
  715.     public function setAdminReview(?string $adminReview): self
  716.     {
  717.         $this->adminReview = $adminReview;
  719.         return $this;
  720.     }
  722.     public function getIsDisabled(): ?bool
  723.     {
  724.         return $this->isDisabled;
  725.     }
  727.     public function setIsDisabled(bool $isDisabled): self
  728.     {
  729.         $this->isDisabled = $isDisabled;
  731.         return $this;
  732.     }
  734.     /**
  735.      * @return Collection|SectionRevision[]
  736.      */
  737.     public function getSectionRevisions(): Collection
  738.     {
  739.         return $this->sectionRevisions;
  740.     }
  742.     /**
  743.      * @return $this
  744.      */
  745.     public function addSectionRevision(SectionRevision $sectionRevision): self
  746.     {
  747.         if (!$this->sectionRevisions->contains($sectionRevision)) {
  748.             $this->sectionRevisions[] = $sectionRevision;
  749.             $sectionRevision->setUser($this);
  750.         }
  752.         return $this;
  753.     }
  755.     /**
  756.      * @return $this
  757.      */
  758.     public function removeSectionRevision(SectionRevision $sectionRevision): self
  759.     {
  760.         if ($this->sectionRevisions->removeElement($sectionRevision)) {
  761.             // set the owning side to null (unless already changed)
  762.             if ($sectionRevision->getUser() === $this) {
  763.                 $sectionRevision->setUser(null);
  764.             }
  765.         }
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection|WorkroomRevision[]
  772.      */
  773.     public function getWorkroomRevisions(): Collection
  774.     {
  775.         return $this->workroomRevisions;
  776.     }
  778.     public function addWorkroomRevision(WorkroomRevision $workroomRevision): self
  779.     {
  780.         if (!$this->workroomRevisions->contains($workroomRevision)) {
  781.             $this->workroomRevisions[] = $workroomRevision;
  782.             $workroomRevision->setUser($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeWorkroomRevision(WorkroomRevision $workroomRevision): self
  789.     {
  790.         if ($this->workroomRevisions->removeElement($workroomRevision)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($workroomRevision->getUser() === $this) {
  793.                 $workroomRevision->setUser(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection|UserWorkroomArena[]
  802.      */
  803.     public function getUserWorkroomArenas(): Collection
  804.     {
  805.         return $this->userWorkroomArenas;
  806.     }
  808.     public function addUserWorkroomArena(UserWorkroomArena $userWorkroomArena): self
  809.     {
  810.         if (!$this->userWorkroomArenas->contains($userWorkroomArena)) {
  811.             $this->userWorkroomArenas[] = $userWorkroomArena;
  812.             $userWorkroomArena->setUser($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeUserWorkroomArena(UserWorkroomArena $userWorkroomArena): self
  819.     {
  820.         if ($this->userWorkroomArenas->removeElement($userWorkroomArena)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($userWorkroomArena->getUser() === $this) {
  823.                 $userWorkroomArena->setUser(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection|SearchQuery[]
  832.      */
  833.     public function getSearchQueries(): Collection
  834.     {
  835.         return $this->searchQueries;
  836.     }
  838.     public function addSearchQuery(SearchQuery $searchQuery): self
  839.     {
  840.         if (!$this->searchQueries->contains($searchQuery)) {
  841.             $this->searchQueries[] = $searchQuery;
  842.             $searchQuery->setUser($this);
  843.         }
  845.         return $this;
  846.     }
  848.     public function removeSearchQuery(SearchQuery $searchQuery): self
  849.     {
  850.         if ($this->searchQueries->removeElement($searchQuery)) {
  851.             // set the owning side to null (unless already changed)
  852.             if ($searchQuery->getUser() === $this) {
  853.                 $searchQuery->setUser(null);
  854.             }
  855.         }
  857.         return $this;
  858.     }
  860.     /**
  861.      * @return Collection|History[]
  862.      */
  863.     public function getHistories(): Collection
  864.     {
  865.         return $this->histories;
  866.     }
  868.     public function addHistory(History $history): self
  869.     {
  870.         if (!$this->histories->contains($history)) {
  871.             $this->histories[] = $history;
  872.             $history->setUser($this);
  873.         }
  875.         return $this;
  876.     }
  878.     public function removeHistory(History $history): self
  879.     {
  880.         if ($this->histories->removeElement($history)) {
  881.             // set the owning side to null (unless already changed)
  882.             if ($history->getUser() === $this) {
  883.                 $history->setUser(null);
  884.             }
  885.         }
  887.         return $this;
  888.     }
  890.     /**
  891.      * @return Collection|HistoryEvent[]
  892.      */
  893.     public function getHistoryEvents(): Collection
  894.     {
  895.         return $this->historyEvents;
  896.     }
  898.     public function addHistoryEvent(HistoryEvent $historyEvent): self
  899.     {
  900.         if (!$this->historyEvents->contains($historyEvent)) {
  901.             $this->historyEvents[] = $historyEvent;
  902.             $historyEvent->setUser($this);
  903.         }
  905.         return $this;
  906.     }
  908.     public function removeHistoryEvent(HistoryEvent $historyEvent): self
  909.     {
  910.         if ($this->historyEvents->removeElement($historyEvent)) {
  911.             // set the owning side to null (unless already changed)
  912.             if ($historyEvent->getUser() === $this) {
  913.                 $historyEvent->setUser(null);
  914.             }
  915.         }
  917.         return $this;
  918.     }
  920.     public function getUserIdentifier(): string
  921.     {
  922.         return $this->getUsername();
  923.     }
  925.     public function getOrganization(): ?Organization
  926.     {
  927.         return $this->organization;
  928.     }
  930.     public function setOrganization(?Organization $organization): static
  931.     {
  932.         $this->organization = $organization;
  934.         return $this;
  935.     }
  937.     public function setZoteroApiKey(?string $zoteroApiKey): self
  938.     {
  939.         $this->zoteroApiKey = $zoteroApiKey;
  941.         return $this;
  942.     }
  944.     public function getZoteroApiKey(): ?string
  945.     {
  946.         return $this->zoteroApiKey;
  947.     }
  949.     public function setZoteroUserId(?string $zoteroUserId): self
  950.     {
  951.         $this->zoteroUserId = $zoteroUserId;
  953.         return $this;
  954.     }
  956.     public function getEmailDomain(): ?string
  957.     {
  958.         if (1 === preg_match('/.*\@(.+)$/i', $this->email, $matches) && count($matches) > 1) {
  959.             return $matches[1];
  960.         }
  961.         return null;
  962.     }
  964.     public function getZoteroUserId(): ?string
  965.     {
  966.         return $this->zoteroUserId;
  967.     }
  969.     public function getSemanticScholarApiKey(): ?string
  970.     {
  971.         return $this->semanticScholarApiKey;
  972.     }
  974.     public function setSemanticScholarApiKey(?string $semanticScholarApiKey): self
  975.     {
  976.         $this->semanticScholarApiKey = $semanticScholarApiKey;
  977.         return $this;
  978.     }
  980.     public function isTwoFactorEnabled(): bool
  981.     {
  982.         return $this->isTwoFactorEnabled;
  983.     }
  985.     public function setIsTwoFactorEnabled(bool $enabled): static
  986.     {
  987.         $this->isTwoFactorEnabled = $enabled;
  988.         return $this;
  989.     }
  991.     public function getTwoFactorCode(): ?string
  992.     {
  993.         return $this->twoFactorCode;
  994.     }
  996.     public function setTwoFactorCode(?string $code): static
  997.     {
  998.         $this->twoFactorCode = $code;
  999.         return $this;
  1000.     }
  1002.     public function getTwoFactorExpiresAt(): ?\DateTimeInterface
  1003.     {
  1004.         return $this->twoFactorExpiresAt;
  1005.     }
  1007.     public function setTwoFactorExpiresAt(?\DateTimeInterface $expiresAt): static
  1008.     {
  1009.         $this->twoFactorExpiresAt = $expiresAt;
  1010.         return $this;
  1011.     }
  1012. }