Slides\Connector\Auth\TokenGuard

Complexity

Total Complexity

23

Size/Duplication

Total Lines	234
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	login()	0	15	3
A	unsafeLogin()	0	15	3
A	syncInstantly()	0	7	2
A	logout()	0	3	1
A	storeToken()	0	5	1
A	user()	0	20	5
A	retrieveUserFromToken()	0	17	3
A	token()	0	13	3
A	validate()	0	3	1

<?php

namespace Slides\Connector\Auth;

use Illuminate\Http\Request;
use Illuminate\Auth\GuardHelpers;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Contracts\Auth\UserProvider;

/**
 * Class TokenGuard
 *
 * @package App\Auth
 */
class TokenGuard implements \Illuminate\Contracts\Auth\Guard
{
    use GuardHelpers;

    /**
     * @var Request
     */
    protected $request;

    /**
     * @var Client
     */
    protected $client;

    /**
     * @var AuthService
     */
    protected $authService;

    /**
     * The name of cookie parameter where bearer token stores.
     *
     * @var string
     */
    protected $authCookie = 'authKey';

    /**
     * The JWT token
     *
     * @var string
     */
    protected $token;

    /**
     * TokenGuard constructor.
     *
     * @param UserProvider $provider
     * @param Request $request
     * @param AuthService $authService
     * @param Client|null $client
     */
    public function __construct(
        UserProvider $provider,
        Request $request,
        AuthService $authService,
        Client $client = null
    )
    {
        $this->provider = $provider;
        $this->request = $request;
        $this->authService = $authService;

        $this->client = $client ?? new Client();
    }

    /**
     * Authenticate a user.
     *
     * @param string $email
     * @param string $password
     * @param bool $remember
     *
     * @return mixed
     *
     * @throws
     */
    public function login(string $email, string $password, bool $remember = false)
    {
        $this->client->request('login', compact('email', 'password', 'remember'));

        if(!$this->client->success()) {
            return false;
        }

        if(!$this->token = $this->client->getToken()) {
            return false;
        }

        $this->storeToken($this->token);

        return $this->token;
    }

    /**
     * Authenticate a user without the password.
     *
     * Warning! This method has implemented temporarily to make able to login users
     * who use Social Auth on 24Templates. MUST NOT be used in any other cases.
     *
     * @param string $email
     * @param string $password
     * @param bool $remember
     *
     * @return mixed
     *
     * @throws
     */
    public function unsafeLogin(string $email, bool $remember = false)
    {
        $this->client->request('unsafeLogin', compact('email', 'remember'));

        if(!$this->client->success()) {
            return false;
        }

        if(!$this->token = $this->client->getToken()) {
            return false;
        }

        $this->storeToken($this->token);

        return $this->token;
    }

    /**
     * Get the currently authenticated user.
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     */
    public function user()
    {
        // If we've already retrieved the user for the current request we can just
        // return it back immediately. We do not want to fetch the user data on
        // every call to this method because that would be tremendously slow.
        if (! is_null($this->user)) {
            return $this->user;
        }

        $user = null;

        if($token = $this->token()) {
            if(!$user = $this->retrieveUserFromToken($token)) {
                if(!$user = $this->syncInstantly()) {
                    $this->logout();
                }
            }
        }

        return $this->user = $user;
    }

    /**
     * Get the token for the current request.
     *
     * @return string|null
     */
    public function token()
    {
        if($this->token) {
            return $this->token;
        }

        $token = $this->request->cookie($this->authCookie);

        if (empty($token)) {
            $token = $this->request->bearerToken();
        }

        return $this->token = $token;
    }

    /**
     * Validate a user's credentials.
     *
     * @param  array  $credentials
     * @return bool
     */
    public function validate(array $credentials = [])
    {
        return true;
    }

    /**
     * Store a token
     *
     * @param string $token
     */
    private function storeToken(string $token)
    {
        $cookie = cookie($this->authCookie, $token);

        Cookie::queue($cookie);
    }

    /**
     * Retrieve a user model from the parsed JWT token.
     *
     * @param string $token
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable|\Illuminate\Database\Query\Builder|null
     */
    private function retrieveUserFromToken(string $token)
    {
        try
        {
            $data = (array) \Firebase\JWT\JWT::decode($token, env('JWT_SECRET'), ['HS256']);
        }
        catch(\RuntimeException $e) {
            $this->logout();

            return null;
        }

        if(!$userId = array_get($data, 'userId')) {
            return null;
        }

        return $this->provider->retrieveByCredentials(['remote_id' => $userId]);
    }

    /**
     * Trying to synchronize a user instantly by requesting using a token.
     *
     * If a user exists remotely, creates locally.
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     */
    private function syncInstantly()
    {
        if($user = $this->authService->retrieveByToken()) {
            return $this->authService->handle('sync.create', ['remote' => $user]);
        }

        return null;
    }

    /**
     * Invalidate a cookie
     *
     * @return void
     */
    public function logout()
    {
        Cookie::queue(Cookie::forget($this->authCookie));
    }
}