BrainExe\Core\Authentication\Token

Complexity

Total Complexity

11

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	addToken()	0	17	1
A	getToken()	0	4	1
A	getTokensForUser()	0	13	3
A	hasUserForRole()	0	13	4
A	revoke()	0	16	2

<?php

namespace BrainExe\Core\Authentication;

use BrainExe\Core\Annotations\Service;
use BrainExe\Core\Traits\IdGeneratorTrait;
use BrainExe\Core\Traits\RedisTrait;
use Generator;

/**
 * @Service
 */
class Token
{

    const USER_KEY  = 'tokens:user:%s';
    const TOKEN_KEY = 'tokens';

    use RedisTrait;
    use IdGeneratorTrait;

    /**
     * @param int $userId
     * @param string[] $roles
     * @param string $name
     * @return string
     */
    public function addToken(int $userId, array $roles = [], string $name = '') : string
    {
        $token = $this->generateRandomId(40);

        $redis = $this->getRedis()->pipeline();

        $redis->sadd(sprintf(self::USER_KEY, $userId), $token);
        $redis->hset(self::TOKEN_KEY, $token, json_encode([
            'userId' => $userId,
            'roles'  => $roles,
            'name'   => $name
        ]));

        $redis->execute();

        return $token;
    }

    /**
     * @param string $token
     * @return array
     */
    public function getToken(string $token)
    {
        return json_decode($this->getRedis()->hget(self::TOKEN_KEY, $token), true);
    }

    /**
     * @param int $userId
     * @return array[]|Generator
     */
    public function getTokensForUser(int $userId)
    {
        $redis     = $this->getRedis();
        $tokensIds = $redis->smembers(sprintf(self::USER_KEY, $userId));

        if (!empty($tokensIds)) {
            $tokens = $redis->hmget(self::TOKEN_KEY, $tokensIds);

            foreach ($tokens as $idx => $token) {
                yield $tokensIds[$idx] => json_decode($token, true);
            }
        }
    }

    /**
     * @param string $token
     * @param string|null $role
     * @return int|null
     */
    public function hasUserForRole(string $token, string $role = null) : ?int
    {
        $tokenData = $this->getToken($token);
        if (empty($tokenData)) {
            return null;
        }

        if ($role && !in_array($role, $tokenData['roles'], true)) {

The expression $role of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return null;
        }

        return $tokenData['userId'];
    }

    /**
     * @param string $token
     */
    public function revoke(string $token)
    {
        $tokenData = $this->getToken($token);
        if (!$tokenData) {

The expression $tokenData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }

        $userId = $tokenData['userId'];

        $redis = $this->getRedis()->pipeline();

        $redis->srem(sprintf(self::USER_KEY, $userId), $token);
        $redis->hdel(self::TOKEN_KEY, $token);

        $redis->execute();
    }
}