Tymon\JWTAuth\Support\auth\AuthenticatesUsers

Complexity

Total Complexity

19

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes	7
Bugs	3	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
C	postLogin()	0	40	7
A	getCredentials()	0	7	2
A	getFailedLoginMessage()	0	6	2
A	loginUsername()	0	4	2
A	isUsingThrottlesLoginsTrait()	0	6	1
A	customClaims()	0	4	2
A	handleUserWasAuthenticated()	0	14	3

<?php
/**
 * Created by PhpStorm.
 * User: Claudio Cardinale <cardi@thecsea.it>
 * Date: 18/11/15
 * Time: 16.52
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

namespace Tymon\JWTAuth\Support\auth;

use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Lang;
use Tymon\JWTAuth\Facades\JWTAuth;

/**
 * Class AuthenticatesUsers
 * @package Tymon\JWTAuth\Support\auth
 * @author Claudio Cardinale <cardi@thecsea.it>
 * @copyright 2015 Claudio Cardinale
 * @version 1.0.0
 */
trait AuthenticatesUsers
{
    /**
     * Handle a login request to the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function postLogin(Request $request)
    {
        $usernames = $this->loginUsername();
        if(!is_array($usernames)) {
            $usernames = [$usernames];
        }
        $usernamesR = [];
        foreach($usernames as $username)
            $usernamesR[$username] = 'required';

        $this->validate($request, array_merge($usernamesR, [

It seems like validate() must be provided by classes using this trait. How about adding it as abstract method to this trait?

             'password' => 'required',
        ]));

        // If the class is using the ThrottlesLogins trait, we can automatically throttle
        // the login attempts for this application. We'll key this by the username and
        // the IP address of the client making these requests into this application.
        $throttles = $this->isUsingThrottlesLoginsTrait();

        if ($throttles && $this->hasTooManyLoginAttempts($request)) {

It seems like hasTooManyLoginAttempts() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $this->sendLockoutResponse($request);

It seems like sendLockoutResponse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        $credentials = $this->getCredentials($request);

        if ($token = JWTAuth::attempt($credentials, $this->customClaims())) {
            return $this->handleUserWasAuthenticated($request, $throttles, $token);
        }

        // If the login attempt was unsuccessful we will increment the number of attempts
        // to login and redirect the user back to the login form. Of course, when this
        // user surpasses their maximum number of attempts they will get locked out.
        if ($throttles) {
            $this->incrementLoginAttempts($request);

It seems like incrementLoginAttempts() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return new JsonResponse([
            implode('.',$usernames) => [$this->getFailedLoginMessage()],
        ], 422);
    }

    /**
     * Send the response after the user was authenticated.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  bool  $throttles
     * @param  string  $token
     * @return \Illuminate\Http\Response
     */
    protected function handleUserWasAuthenticated(Request $request, $throttles, $token)
    {
        if ($throttles) {
            $this->clearLoginAttempts($request);

It seems like clearLoginAttempts() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if (method_exists($this, 'authenticated')) {
            return $this->authenticated($request, $token);

The method authenticated() does not exist on Tymon\JWTAuth\Support\auth\AuthenticatesUsers. Did you maybe mean handleUserWasAuthenticated()?

        }

        $response = new JsonResponse(['token' => $token], 200);
        $response->header('Authorization', 'Bearer ' . $token);
        return $response;
    }

    /**
     * Get the needed authorization credentials from the request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    protected function getCredentials(Request $request)
    {
        $usernames = $this->loginUsername();
        if(!is_array($usernames))
            $usernames = [$usernames];
        return $request->only(array_merge($usernames, ['password']));
    }

    /**
     * Get the failed login message.
     *
     * @return string
     */
    protected function getFailedLoginMessage()
    {
        return Lang::has('auth.failed')
            ? Lang::get('auth.failed')
            : 'These credentials do not match our records.';
    }

    /**
     * Get the login username to be used by the controller.
     * it can be an array for multiple username (for example email and phone number)
     *
     * @return string|array
     */
    public function loginUsername()
    {
        return property_exists($this, 'username') ? $this->username : 'email';

The property username does not exist. Did you maybe forget to declare it?

    }

    /**
     * Determine if the class is using the ThrottlesLogins trait.
     *
     * @return bool
     */
    protected function isUsingThrottlesLoginsTrait()
    {
        return in_array(
            ThrottlesLogins::class, class_uses_recursive(get_class($this))
        );
    }

    /**
     * Get the custom claims
     *
     * @return string
     */
    public function customClaims()
    {
        return property_exists($this, 'custom') ? $this->custom : [];

The property custom does not exist. Did you maybe forget to declare it?

    }
}