BaseGuard::__construct() - Code Metrics - Inspection of "split special guard functions to top class" - canis-io/lumen-jwt-auth - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9d09aa...80b42f )

by Jacob

created 2016-02-19 03:28 UTC

BaseGuard::__construct() A

↳ Parent: BaseGuard

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	6
ccs	5
cts	5
cp	1
rs	9.4285
cc	1
eloc	4
nc	1
nop	3
crap	1

<?php
/**
 * @copyright Copyright (c) 2016 Canis.io
 * @license   MIT
 */
namespace Canis\Lumen\Jwt;

use Illuminate\Http\Request;
use Illuminate\Auth\GuardHelpers;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Guard as GaurdContract;
use Illuminate\Contracts\Auth\Authenticatable;
use Canis\Lumen\Jwt\Exceptions\InvalidTokenException;
use Canis\Lumen\Jwt\Exceptions\InvalidAdapterException;
use Canis\Lumen\Jwt\Contracts\AdapterFactory as AdapterFactoryContract;
use Canis\Lumen\Jwt\Contracts\Processor as ProcessorContract;
use Canis\Lumen\Jwt\Contracts\Subject as SubjectContract;

abstract class BaseGuard
    implements GaurdContract

{
    use GuardHelpers;

    const JWT_GUARD_CLAIM = 'grd';

    /**
     * @var string
     */
    protected $id;

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

    /**
     * Constructor
     *
     * @param UserProvider $provider
     * @param Request      $request
     */
    public function __construct($id, UserProvider $provider, Request $request)
    {
        $this->request = $request;
        $this->provider = $provider;
        $this->id = $id;
    }

    /**
     * Returns the adapter class name to use
     *
     * @return string
     */
    public function getAdapterFactoryClass()
    {
        $config = config('jwt');
        if (!isset($config['adapter'])) {
            $config['adapter'] = 'lcobucci';
        }
        if (class_exists($config['adapter'])) {
            $factoryClass = $config['adapter'];
        } else {
            $factoryClass = 'Canis\Lumen\Jwt\Adapters\\' . ucfirst($config['adapter']) . '\Factory';
            if (!class_exists($factoryClass)) {
                throw new InvalidAdapterException("{$config['adapter']} is not available");
            }
        }
        return $factoryClass;
    }

    /**
     * Returns the adapter factory object
     *
     * @return AdapterFactoryContract
     */
    protected function getAdapterFactory()
    {
        static $factory;
        if (!isset($factory)) {
            $config = config('jwt');
            $factoryClass = $this->getAdapterFactoryClass();
            $factory = new $factoryClass($config);
        }
        return $factory;
    }

    /**
     * Returns a token processor from the adapter factory
     *
     * @return ProcessorContract
     */
    protected function getProcessor()
    {
        return $this->getAdapterFactory()->getProcessor();
    }

    /**
     * Returns a token generator from the adapter factory
     *
     * @return GeneratorContract
     */
    protected function getGenerator()
    {
        return $this->getAdapterFactory()->getGenerator();
    }

    /**
     * Gets the provider
     *
     * @return UserProvider
     */
    public function getProvider()
    {
        return $this->provider;
    }

    /**
     * @inheritdoc
     */
    public function user()
    {
        if (!is_null($this->user)) {
            return $this->user;
        }
        $user = null;
        $token = $this->getBearerToken();
        if ($token !== false) {
            $user = $this->getProvider()->retrieveById($token->getClaim('sub'));
            $claimValidation = [static::JWT_GUARD_CLAIM => $this->id];
            if (!($user instanceof SubjectContract)
                || !$token->ensureClaimValues(array_merge($user->getJWTClaimValidation(), $claimValidation))) {
                $user = null;
            }
        }
        return $this->user = $user;
    }

    /**
     * @inheritdoc
     */
    public function getBearerToken($isRefresh = false)
    {
        $token = $this->request->bearerToken();
        if (empty($token)) {
            return false;
        }
        $processor = $this->getProcessor();
        return $processor($token, $isRefresh);
    }

    /**
     * @inheritdoc
     */
    public function validate(array $credentials = [])
    {
        $user = $this->getProvider()->retrieveByCredentials($credentials);
        if ($user instanceof Authenticatable && $this->hasValidCredentials($user, $credentials)) {
            return true;
        }
        return false;
    }

    /**
     * Determine if the user matches the credentials.
     *
     * @param  Authenticatable|null  $user
     * @param  array  $credentials
     * @return bool
     */
    protected function hasValidCredentials($user, $credentials)
    {
        return !is_null($user) && $this->getProvider()->validateCredentials($user, $credentials);
    }

    /**
     * Sets the Request
     *
     * @param Request $request
     */
    public function setRequest(Request $request)
    {
        $this->request = $request;
    }

    /**
     * Gets the request
     *
     * @return Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Attempt to authenticate a user using the given credentials.
     *
     * @param  array  $credentials
     * @return bool|Token
     */
    public function attempt(array $credentials = [])
    {
        $user = $this->getProvider()->retrieveByCredentials($credentials);
        if ($user instanceof Authenticatable && $this->hasValidCredentials($user, $credentials)) { 
            if (!($user instanceof SubjectContract)) {
                throw new InvalidTokenException("Unable to generate token");
            }
            return $this->generateToken($user);
        }
        return false;
    }

    /**
     * Generate a new token
     * 
     * @param  SubjectContract $user
     * @return Token
     */
    protected function generateToken(SubjectContract $user)
    {
        $tokenGenerator = $this->getGenerator();
        $claims = $user->getJWTClaims();
        $claims['sub'] = $user->getJWTSubject();
        $claims[static::JWT_GUARD_CLAIM] = $this->id;
        if (!($token = $tokenGenerator($claims))) {
            throw new InvalidTokenException("Unable to generate token");
        }
        return $token;
    }
}


1		<?php
2		/**
3		* @copyright Copyright (c) 2016 Canis.io
4		* @license MIT
5		*/
6		namespace Canis\Lumen\Jwt;
7
8		use Illuminate\Http\Request;
9		use Illuminate\Auth\GuardHelpers;
10		use Illuminate\Contracts\Auth\UserProvider;
11		use Illuminate\Contracts\Auth\Guard as GaurdContract;
12		use Illuminate\Contracts\Auth\Authenticatable;
13		use Canis\Lumen\Jwt\Exceptions\InvalidTokenException;
14		use Canis\Lumen\Jwt\Exceptions\InvalidAdapterException;
15		use Canis\Lumen\Jwt\Contracts\AdapterFactory as AdapterFactoryContract;
16		use Canis\Lumen\Jwt\Contracts\Processor as ProcessorContract;
17		use Canis\Lumen\Jwt\Contracts\Subject as SubjectContract;
18
19		abstract class BaseGuard
20		implements GaurdContract
		0 ignored issues – show Coding Style introduced 2016-02-17 19:32 UTC by Report Bug Copy Issue Report The implements keyword must be on the same line as the class name Loading history...
21		{
22		use GuardHelpers;
23
24		const JWT_GUARD_CLAIM = 'grd';
25
26		/**
27		* @var string
28		*/
29		protected $id;
30
31		/**
32		* @var Request
33		*/
34		protected $request;
35
36		/**
37		* Constructor
38		*
39		* @param UserProvider $provider
40		* @param Request $request
41		*/
42	22	public function __construct($id, UserProvider $provider, Request $request)
43		{
44	22	$this->request = $request;
45	22	$this->provider = $provider;
46	22	$this->id = $id;
47	22	}
48
49		/**
50		* Returns the adapter class name to use
51		*
52		* @return string
53		*/
54	15	public function getAdapterFactoryClass()
55		{
56	15	$config = config('jwt');
57	15	if (!isset($config['adapter'])) {
58	13	$config['adapter'] = 'lcobucci';
59	13	}
60	15	if (class_exists($config['adapter'])) {
61	1	$factoryClass = $config['adapter'];
62	1	} else {
63	14	$factoryClass = 'Canis\Lumen\Jwt\Adapters\\' . ucfirst($config['adapter']) . '\Factory';
64	14	if (!class_exists($factoryClass)) {
65	1	throw new InvalidAdapterException("{$config['adapter']} is not available");
66		}
67		}
68	14	return $factoryClass;
69		}
70
71		/**
72		* Returns the adapter factory object
73		*
74		* @return AdapterFactoryContract
75		*/
76	15	protected function getAdapterFactory()
77		{
78	15	static $factory;
79	15	if (!isset($factory)) {
80	15	$config = config('jwt');
81	15	$factoryClass = $this->getAdapterFactoryClass();
82	14	$factory = new $factoryClass($config);
83	14	}
84	14	return $factory;
85		}
86
87		/**
88		* Returns a token processor from the adapter factory
89		*
90		* @return ProcessorContract
91		*/
92	11	protected function getProcessor()
93		{
94	11	return $this->getAdapterFactory()->getProcessor();
95		}
96
97		/**
98		* Returns a token generator from the adapter factory
99		*
100		* @return GeneratorContract
101		*/
102	7	protected function getGenerator()
103		{
104	7	return $this->getAdapterFactory()->getGenerator();
105		}
106
107		/**
108		* Gets the provider
109		*
110		* @return UserProvider
111		*/
112	14	public function getProvider()
113		{
114	14	return $this->provider;
115		}
116
117		/**
118		* @inheritdoc
119		*/
120	5	public function user()
121		{
122	5	if (!is_null($this->user)) {
123	3	return $this->user;
124		}
125	5	$user = null;
126	5	$token = $this->getBearerToken();
127	5	if ($token !== false) {
128	5	$user = $this->getProvider()->retrieveById($token->getClaim('sub'));
129	5	$claimValidation = [static::JWT_GUARD_CLAIM => $this->id];
130	5	if (!($user instanceof SubjectContract)
131	5	\|\| !$token->ensureClaimValues(array_merge($user->getJWTClaimValidation(), $claimValidation))) {
132	2	$user = null;
133	2	}
134	5	}
135	5	return $this->user = $user;
136		}
137
138		/**
139		* @inheritdoc
140		*/
141	12	public function getBearerToken($isRefresh = false)
142		{
143	12	$token = $this->request->bearerToken();
144	12	if (empty($token)) {
145	2	return false;
146		}
147	10	$processor = $this->getProcessor();
148	10	return $processor($token, $isRefresh);
149		}
150
151		/**
152		* @inheritdoc
153		*/
154	2	public function validate(array $credentials = [])
155		{
156	2	$user = $this->getProvider()->retrieveByCredentials($credentials);
157	2	if ($user instanceof Authenticatable && $this->hasValidCredentials($user, $credentials)) {
158	1	return true;
159		}
160	1	return false;
161		}
162
163		/**
164		* Determine if the user matches the credentials.
165		*
166		* @param Authenticatable\|null $user
167		* @param array $credentials
168		* @return bool
169		*/
170	6	protected function hasValidCredentials($user, $credentials)
171		{
172	6	return !is_null($user) && $this->getProvider()->validateCredentials($user, $credentials);
173		}
174
175		/**
176		* Sets the Request
177		*
178		* @param Request $request
179		*/
180	1	public function setRequest(Request $request)
181		{
182	1	$this->request = $request;
183	1	}
184
185		/**
186		* Gets the request
187		*
188		* @return Request
189		*/
190	1	public function getRequest()
191		{
192	1	return $this->request;
193		}
194
195		/**
196		* Attempt to authenticate a user using the given credentials.
197		*
198		* @param array $credentials
199		* @return bool\|Token
200		*/
201	4	public function attempt(array $credentials = [])
202		{
203	4	$user = $this->getProvider()->retrieveByCredentials($credentials);
204	4	if ($user instanceof Authenticatable && $this->hasValidCredentials($user, $credentials)) {
205	3	if (!($user instanceof SubjectContract)) {
206	1	throw new InvalidTokenException("Unable to generate token");
207		}
208	2	return $this->generateToken($user);
209		}
210	1	return false;
211		}
212
213		/**
214		* Generate a new token
215		*
216		* @param SubjectContract $user
217		* @return Token
218		*/
219	4	protected function generateToken(SubjectContract $user)
220		{
221	4	$tokenGenerator = $this->getGenerator();
222	4	$claims = $user->getJWTClaims();
223	4	$claims['sub'] = $user->getJWTSubject();
224	4	$claims[static::JWT_GUARD_CLAIM] = $this->id;
225	4	if (!($token = $tokenGenerator($claims))) {
226	1	throw new InvalidTokenException("Unable to generate token");
227		}
228	3	return $token;
229		}
230		}
231

canis-io / lumen-jwt-auth

Push — master ( 9d09aa...80b42f )

BaseGuard::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like