BrainExe\Core\Authentication\UserProvider

Complexity

Total Complexity

13

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	loadUserByUsername()	0	4	1
A	loadUserById()	0	4	1
A	getAllUserNames()	0	4	1
A	generateHash()	0	4	1
A	verifyHash()	0	4	1
A	changePassword()	0	7	1
A	setUserProperty()	0	10	2
A	register()	0	23	1
A	deleteUser()	0	17	2
A	getKey()	0	4	1

<?php

namespace BrainExe\Core\Authentication;

use BrainExe\Core\Annotations\Service;
use BrainExe\Core\Authentication\Event\DeleteUserEvent;
use BrainExe\Core\Authentication\Exception\UserNotFoundException;
use BrainExe\Core\Traits\EventDispatcherTrait;
use BrainExe\Core\Traits\IdGeneratorTrait;
use BrainExe\Core\Traits\RedisTrait;

/**
 * @Service
 */
class UserProvider
{

    use RedisTrait;
    use IdGeneratorTrait;
    use EventDispatcherTrait;

    const REDIS_USER       = 'user:%d';
    const REDIS_USER_NAMES = 'user_names';

    /**
     * @var PasswordHasher
     */
    private $hasher;

    /**
     * @var LoadUser
     */
    private $loadUser;

    /**
     * @param PasswordHasher $passwordHasher
     * @param LoadUser $loadUser
     */
    public function __construct(PasswordHasher $passwordHasher, LoadUser $loadUser)
    {
        $this->hasher   = $passwordHasher;
        $this->loadUser = $loadUser;
    }

    /**
     * @param string $username
     * @return UserVO
     * @throws UserNotFoundException
     */
    public function loadUserByUsername(string $username) : UserVO
    {
        return $this->loadUser->loadUserByUsername($username);
    }

    /**
     * @param int $userId
     * @return UserVO
     * @throws UserNotFoundException
     */
    public function loadUserById(int $userId) : UserVO
    {
        return $this->loadUser->loadUserById($userId);
    }

    /**
     * @return string[]
     */
    public function getAllUserNames() : array
    {
        return $this->getRedis()->hgetall(self::REDIS_USER_NAMES);
    }

    /**
     * @param string $password
     * @return string $hash
     */
    public function generateHash(string $password) : string
    {
        return $this->hasher->generateHash($password);
    }

    /**
     * @param string $password
     * @param string $hash
     * @return bool
     */
    public function verifyHash(string $password, string $hash) : bool
    {
        return $this->hasher->verifyHash($password, $hash);
    }

    /**
     * @param UserVO $user
     * @param string $newPassword
     */
    public function changePassword(UserVO $user, string $newPassword)
    {
        $hash = $this->generateHash($newPassword);
        $user->password = $hash;

        $this->setUserProperty($user, 'password');
    }

    /**
     * @param UserVO $userVo
     * @param string $property
     */
    public function setUserProperty(UserVO $userVo, string $property)
    {
        $redis = $this->getRedis();
        $value = $userVo->$property;

        if (is_array($value)) {
            $value = implode(',', $value);
        }
        $redis->hset($this->getKey($userVo->id), $property, $value);
    }

    /**
     * @param UserVO $user
     * @return int $userId
     */
    public function register(UserVO $user) : int
    {
        $redis = $this->getRedis()->pipeline();

        $userArray = [
            'username' => $user->getUsername(),
            'password' => $this->generateHash($user->password),
            'roles'    => implode(',', $user->roles),
            'one_time_secret' => $user->one_time_secret,
            'avatar'   => $user->avatar
        ];

        $newUserId = $this->generateUniqueId('userid');

        $redis->hset(self::REDIS_USER_NAMES, mb_strtolower($user->getUsername()), $newUserId);
        $redis->hmset($this->getKey($newUserId), $userArray);

        $redis->execute();

        $user->id = $newUserId;

        return $newUserId;
    }

    /**
     * @param int $userId
     * @return bool
     */
    public function deleteUser(int $userId) : bool
    {
        try {
            $user = $this->loadUser->loadUserById($userId);
        } catch (UserNotFoundException $e) {
            return false;
        }

        $event = new DeleteUserEvent($user, DeleteUserEvent::DELETE);
        $this->dispatchEvent($event);

        $redis = $this->getRedis();
        $redis->hdel(self::REDIS_USER_NAMES, mb_strtolower($user->getUsername()));
        $redis->del($this->getKey($userId));

        return true;
    }

    /**
     * @param int $userId
     * @return string
     */
    private function getKey(int $userId) : string
    {
        return sprintf(self::REDIS_USER, $userId);
    }
}