Аутентификация с JWT Lumen без пароля

Question

Я использую JWT в просвете, и я не смог получить маркер без пароля только с электронной почтой и я использую этот код формы stack overflow -

$user=User::where('email','=','user2@gmail.com')->first(); 

if (!$userToken=JWTAuth::fromUser($user)) { 
      return response()->json(['error' => 'invalid_credentials'], 401); 
     } 

return response()->json(compact('userToken')); 



This code give me error like this -> 

ErrorException in UserController.php line 44: 
Non-static method Tymon\JWTAuth\JWT::fromUser() should not be called statically, assuming $this from incompatible context 

Мой контроллер UserController.php -

namespace App\Http\Controllers\v1; 

use Illuminate\Http\Request; 
use Illuminate\Http\Response; 
use Exception; 
use Cartalyst\Sentinel\Native\Facades\Sentinel; 
use Cartalyst\Sentinel\Laravel\Facades\Activation; 
use Tymon\JWTAuth\JWTAuth; 
use Illuminate\Support\Facades\Mail; 
use App\Model\User; 
use Tymon\JWTAuth\Exceptions\JWTException; 
use Tymon\JWTAuth\Exceptions\TokenExpiredException; 
use Tymon\JWTAuth\Exceptions\TokenInvalidException; 

My - Config/авторизация

<?php 

return [ 

    /* 
    |-------------------------------------------------------------------------- 
    | Authentication Defaults 
    |-------------------------------------------------------------------------- 
    | 
    | This option controls the default authentication "guard" and password 
    | reset options for your application. You may change these defaults 
    | as required, but they're a perfect start for most applications. 
    | 
    */ 

    'defaults' => [ 
     'guard' => env('AUTH_GUARD', 'api'), 
     'passwords' => 'users', 
    ], 

    /* 
    |-------------------------------------------------------------------------- 
    | Authentication Guards 
    |-------------------------------------------------------------------------- 
    | 
    | Next, you may define every authentication guard for your application. 
    | Of course, a great default configuration has been defined for you 
    | here which uses session storage and the Eloquent user provider. 
    | 
    | All authentication drivers have a user provider. This defines how the 
    | users are actually retrieved out of your database or other storage 
    | mechanisms used by this application to persist your user's data. 
    | 
    | Supported: "session", "token" 
    | 
    */ 
    'guards' => [ 
     'api' => [ 
      'driver'  => 'jwt', 
      'provider' => 'users', 
      'identifier' => 'email', 
      'password' => 'password', 
     ], 
    ], 

    /* 
    |-------------------------------------------------------------------------- 
    | User Providers 
    |-------------------------------------------------------------------------- 
    | 
    | All authentication drivers have a user provider. This defines how the 
    | users are actually retrieved out of your database or other storage 
    | mechanisms used by this application to persist your user's data. 
    | 
    | If you have multiple user tables or models you may configure multiple 
    | sources which represent each model/table. These sources may then 
    | be assigned to any extra authentication guards you have defined. 
    | 
    | Supported: "database", "eloquent" 
    | 
    */ 

    'providers' => [ 
     'users' => [ 
      'driver' => 'eloquent', 
      'model' => \App\User::class, 
     ], 
    ], 

    /* 
    |-------------------------------------------------------------------------- 
    | Resetting Passwords 
    |-------------------------------------------------------------------------- 
    | 
    | Here you may set the options for resetting passwords including the view 
    | that is your password reset e-mail. You may also set the name of the 
    | table that maintains all of the reset tokens for your application. 
    | 
    | You may specify multiple password reset configurations if you have more 
    | than one user table or model in the application and you want to have 
    | separate password reset settings based on the specific user types. 
    | 
    | The expire time is the number of minutes that the reset token should be 
    | considered valid. This security feature keeps tokens short-lived so 
    | they have less time to be guessed. You may change this as needed. 
    | 
    */ 

    'passwords' => [ 
     // 
    ], 

]; 

Мой самозагрузки/приложение

<?php 

require_once __DIR__ . '/../vendor/autoload.php'; 

try { 
    (new Dotenv\Dotenv(__DIR__ . '/../'))->load(); 
} catch (Dotenv\Exception\InvalidPathException $e) { 
    // 
} 

/* 
    |-------------------------------------------------------------------------- 
    | Create The Application 
    |-------------------------------------------------------------------------- 
    | 
    | Here we will load the environment and create the application instance 
    | that serves as the central piece of this framework. We'll use this 
    | application as an "IoC" container and router for this framework. 
    | 
*/ 

$app = new Laravel\Lumen\Application(
     realpath(__DIR__ . '/../') 
); 

$app->withFacades(); 

$app->configure('jwt'); 
$app->configure('auth'); 

class_alias(Tymon\JWTAuth\Facades\JWTAuth::class, 'JWTAuth'); 
class_alias(Tymon\JWTAuth\Facades\JWTFactory::class, 'JWTFactory'); 

$app->withEloquent(); 

/* 
    |-------------------------------------------------------------------------- 
    | Register Container Bindings 
    |-------------------------------------------------------------------------- 
    | 
    | Now we will register a few bindings in the service container. We will 
    | register the exception handler and the console kernel. You may add 
    | your own bindings here if you like or you can make another file. 
    | 
*/ 

$app->singleton(
    Illuminate\Contracts\Debug\ExceptionHandler::class, 
    App\Exceptions\Handler::class 
); 

$app->singleton(
    Illuminate\Contracts\Console\Kernel::class, 
    App\Console\Kernel::class 
); 

$app->singleton(
    Illuminate\Contracts\Routing\ResponseFactory::class, 
    Illuminate\Routing\ResponseFactory::class 
); 


/* 
    |-------------------------------------------------------------------------- 
    | Register Middleware 
    |-------------------------------------------------------------------------- 
    | 
    | Next, we will register the middleware with the application. These can 
    | be global middleware that run before and after each request into a 
    | route or middleware that'll be assigned to some specific routes. 
    | 
*/ 
// $app->middleware([ 
// App\Http\Middleware\ExampleMiddleware::class 
// ]); 

$app->routeMiddleware([ 
    'auth'  => App\Http\Middleware\Authenticate::class, 
    'jwt.auth' => Tymon\JWTAuth\Middleware\GetUserFromToken::class, 
    'jwt.refresh' => Tymon\JWTAuth\Middleware\RefreshToken::class, 
]); 

/* 
    |-------------------------------------------------------------------------- 
    | Register Service Providers 
    |-------------------------------------------------------------------------- 
    | 
    | Here we will register all of the application's service providers which 
    | are used to bind services into the container. Service providers are 
    | totally optional, so you are not required to uncomment this line. 
    | 
*/ 

$app->register(App\Providers\AppServiceProvider::class); 
$app->register(App\Providers\AuthServiceProvider::class); 
$app->register(App\Providers\EventServiceProvider::class); 

$app->register(Tymon\JWTAuth\Providers\LumenServiceProvider::class); 
/* 
    |-------------------------------------------------------------------------- 
    | Load The Application Routes 
    |-------------------------------------------------------------------------- 
    | 
    | Next we will include the routes file so that they can all be added to 
    | the application. This will provide all of the URLs the application 
    | can respond to, as well as the controllers that may handle them. 
    | 
*/ 

$app->group(['namespace' => 'App\Http\Controllers'], function ($app) { 
    require __DIR__ . '/../app/Http/routes.php'; 
}); 

return $app; 

Моя модель пользователя -

<?php 

namespace App; 

use Illuminate\Auth\Authenticatable; 
use Laravel\Lumen\Auth\Authorizable; 
use Illuminate\Database\Eloquent\Model; 
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract; 
use Illuminate\Contracts\Auth\Access\Authorizable as AuthorizableContract; 
use Tymon\JWTAuth\Contracts\JWTSubject; 

class User extends Model implements JWTSubject, AuthenticatableContract, AuthorizableContract { 

    use Authenticatable, 
     Authorizable; 

    /** 
    * The attributes that are mass assignable. 
    * 
    * @var array 
    */ 
    protected $fillable = [ 
     'name', 'email', 
    ]; 

    /** 
    * The attributes excluded from the model's JSON form. 
    * 
    * @var array 
    */ 
    protected $hidden = [ 
     'password', 
    ]; 

    public function getJWTIdentifier() { 
     return $this->getKey(); 
    } 

    public function getJWTCustomClaims() { 
     return []; 
    } 

} 

My - JwtSubject -

<?php 

/* 
* This file is part of jwt-auth. 
* 
* (c) Sean Tymon <tymon148@gmail.com> 
* 
* For the full copyright and license information, please view the LICENSE 
* file that was distributed with this source code. 
*/ 

namespace Tymon\JWTAuth\Contracts; 

interface JWTSubject 
{ 
    /** 
    * Get the identifier that will be stored in the subject claim of the JWT. 
    * 
    * @return mixed 
    */ 
    public function getJWTIdentifier(); 

    /** 
    * Return a key value array, containing any custom claims to be added to the JWT. 
    * 
    * @return array 
    */ 
    public function getJWTCustomClaims(); 
} 

Моя функция __construct

класс UserController расширяет контроллер {

public $request; 
protected $jwt; 

public function __construct(Request $request, JWTAuth $jwt) { 
    try { 
     $this->request = $request; 
     $this->jwt = $jwt; 
    } catch (Exception $ex) { 
     \Log::error("Error : " . $ex); 
     $output = array('success' => false, 'result' => null, 'error' => $ex, 'error_key' => 'unhandled_exception'); 
     return new Response($output); 
    } 
} 

Пожалуйста, помогите мне, как я могу получить токен, используя только электронную почту.

Answer 1

Проблема вызвана этим оператором use в вашем UserController.

use Tymon\JWTAuth\JWTAuth; 

При вызове JWTAuth::fromUser($user) вы не ссылки на фасад (который содержит экземпляр JWTAuth уже), но фактическую функцию из класса, который вы не можете, потому что это не называется статически.

Это то, что строит Фасад:

class_alias(Tymon\JWTAuth\Facades\JWTAuth::class, 'JWTAuth'); 

Удалить, что use заявление, и вы должны быть в порядке.

Или измените его на use JWTAuth;, чтобы правильно ссылаться на Фасад, доступный по всему миру.