SessionAuthAdapter::refreshUser() - Code Metrics - Inspection of "Merge pull request #330 from armanist/329-Add-refr..." - softberg/quantum-php-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 67e20f...a3a272 )

by Arman
created 2025-10-14 13:50 UTC
SessionAuthAdapter::refreshUser() A

↳ Parent: SessionAuthAdapter
Complexity

Conditions	2
Paths	2
Size

Total Lines	14
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	0
loc	14
rs	10
c	0
b	0
f	0
<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <[email protected]>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.9.7
 */

namespace Quantum\Libraries\Auth\Adapters;

use Quantum\Libraries\Auth\Contracts\AuthenticatableInterface;
use Quantum\Libraries\Database\Exceptions\DatabaseException;
use Quantum\Libraries\Auth\Contracts\AuthServiceInterface;
use Quantum\Libraries\Session\Exceptions\SessionException;
use Quantum\Libraries\Auth\Exceptions\AuthException;
use Quantum\Config\Exceptions\ConfigException;
use Quantum\Libraries\Auth\Constants\AuthKeys;
use Quantum\Libraries\Auth\Traits\AuthTrait;
use Quantum\App\Exceptions\BaseException;
use Quantum\Di\Exceptions\DiException;
use Quantum\Libraries\Hasher\Hasher;
use Quantum\Libraries\Mailer\Mailer;
use Quantum\Libraries\Auth\User;
use ReflectionException;
use Exception;

/**
 * Class WebAuth
 * @package Quantum\Libraries\Auth
 */
class SessionAuthAdapter implements AuthenticatableInterface
{

    use AuthTrait;

    /**
     * @param AuthServiceInterface $authService
     * @param Mailer $mailer
     * @param Hasher $hasher
     * @throws AuthException
     */
    public function __construct(AuthServiceInterface $authService, Mailer $mailer, Hasher $hasher)
    {
        $this->authService = $authService;
        $this->mailer = $mailer;

        $this->hasher = $hasher;

        $this->verifySchema($this->authService->userSchema());
    }

    /**
     * @inheritDoc
     * @throws AuthException
     * @throws ConfigException
     * @throws DatabaseException
     * @throws DiException
     * @throws ReflectionException
     * @throws SessionException
     * @throws Exception
     */
    public function signin(string $username, string $password, bool $remember = false)
    {
        $user = $this->getUser($username, $password);

        if ($remember) {
            $this->setRememberToken($user);
        }

        if ($this->isTwoFactorEnabled()) {
            return $this->twoStepVerification($user);
        }

        session()->regenerateId();
        session()->set(self::AUTH_USER, $this->getVisibleFields($user));

        return true;
    }

    /**
     * @inheritDoc
     * @throws ConfigException
     * @throws DiException
     * @throws ReflectionException
     * @throws BaseException
     */
    public function signout(): bool
    {
        if (session()->has(self::AUTH_USER)) {
            session()->delete(self::AUTH_USER);
            session()->regenerateId();
            $this->removeRememberToken();

            return true;
        }

        return false;
    }

    /**
     * @inheritDoc
     * @throws BaseException
     * @throws ConfigException
     * @throws DiException
     * @throws ReflectionException
     */
    public function user(): ?User
    {
        if (session()->has(self::AUTH_USER) && is_array(session()->get(self::AUTH_USER))) {
            return (new User())->setData(session()->get(self::AUTH_USER));
            return (new User())->setData(/** @scrutinizer ignore-type */ session()->get(self::AUTH_USER));
        }

        if (cookie()->has($this->keyFields[AuthKeys::REMEMBER_TOKEN])) {
            $user = $this->checkRememberToken();

            if ($user) {
                session()->set(self::AUTH_USER, $this->getVisibleFields($user));
                return $this->user();
            }
        }

        return null;
    }

    /**
     * Refresh user data
     * @param string $uuid
     * @return bool
     * @throws BaseException
     * @throws ConfigException
     * @throws DiException
     * @throws ReflectionException
     */
    public function refreshUser(string $uuid): bool
    {
        $user = $this->authService->get('uuid', $uuid);

        if (!$user) {
            return false;
        }

        $sessionData = session()->get(self::AUTH_USER);
        $sessionData = array_merge($sessionData, $this->getVisibleFields($user));
        $sessionData = array_merge(/** @scrutinizer ignore-type */ $sessionData, $this->getVisibleFields($user));

        session()->set(self::AUTH_USER, $sessionData);

        return true;
    }

    /**
     * Verify OTP
     * @param int $otp
     * @param string $otpToken
     * @return bool
     * @throws AuthException
     * @throws BaseException
     * @throws ConfigException
     * @throws DiException
     * @throws ReflectionException
     */
    public function verifyOtp(int $otp, string $otpToken): bool
    {
        $user = $this->verifyAndUpdateOtp($otp, $otpToken);

        session()->set(self::AUTH_USER, $this->getVisibleFields($user));

        return true;
    }

    /**
     * Check Remember Token
     * @return User|false
     */
    private function checkRememberToken()
    {
        $user = $this->authService->get(
            $this->keyFields[AuthKeys::REMEMBER_TOKEN],
            cookie()->get($this->keyFields[AuthKeys::REMEMBER_TOKEN])
        );

        if (!$user) {
            return false;
        }

        if ($this->isTwoFactorEnabled() && !empty($user->getFieldValue($this->keyFields[AuthKeys::OTP_TOKEN]))) {
            return false;
        }

        return $user;
    }

    /**
     * Set Remember Token
     * @param User $user
     */
    private function setRememberToken(User $user)
    {
        $rememberToken = $this->generateToken();

        $this->authService->update(
            $this->keyFields[AuthKeys::USERNAME],
            $user->getFieldValue($this->keyFields[AuthKeys::USERNAME]),
            [$this->keyFields[AuthKeys::REMEMBER_TOKEN] => $rememberToken]
        );

        cookie()->set($this->keyFields[AuthKeys::REMEMBER_TOKEN], $rememberToken);
    }

    /**
     * Remove Remember token
     */
    private function removeRememberToken()
    {
        if (cookie()->has($this->keyFields[AuthKeys::REMEMBER_TOKEN])) {
            $user = $this->authService->get(
                $this->keyFields[AuthKeys::REMEMBER_TOKEN],
                cookie()->get($this->keyFields[AuthKeys::REMEMBER_TOKEN])
            );

            if ($user) {
                $this->authService->update(
                    $this->keyFields[AuthKeys::REMEMBER_TOKEN],
                    $user->getFieldValue($this->keyFields[AuthKeys::REMEMBER_TOKEN]),
                    [$this->keyFields[AuthKeys::REMEMBER_TOKEN] => '']
                );
            }

            cookie()->delete($this->keyFields[AuthKeys::REMEMBER_TOKEN]);
        }
    }
}
softberg / quantum-php-core

Push — master ( 67e20f...a3a272 )

SessionAuthAdapter::refreshUser() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
