Laravel 5 API RESTful - Comprendre les concepts de ressources

Question

Je développe une API RESTful avec Laravel 5. J'ai des ressources dans mon fichier routes.php et tout fonctionne correctement.

Mais maintenant j'avais ajouté auth.basic middleware et je veux introduire les rôles de l'utilisateur et je me suis trompé.

Dans mon contrôleur, j'ai un constructeur pour appeler 2 middleware, auth.basic et rôles middleware, mais ne peut pas continuer en raison d'un manque de connaissances.

De quoi ai-je besoin? Eh bien, j'ai besoin de définir les rôles utilisateur qui peuvent accéder à chaque contrôleur, mais ne peux pas y parvenir. Im le contrôleur Je voudrais accéder à l'utilisateur pour vérifier son rôle et le comparer avec le rôle établi sur le contrôleur, mais je ne sais pas comment accéder à l'utilisateur, pouvez-vous m'aider?

EDIT:

Je mets cela sur le constructeur du contrôleur

public function __construct(Request $request) 
    { 
    $actions = $request->route()->setAction(['roles' => ['admin', 'seller', 'buyer']]); 
    $this->middleware('auth.basic'); 
    $this->middleware('roles'); 
    } 

Fondamentalement, j'Injecter la demande dans le constructeur du contrôleur, puis je mis une action appelée rôles. Ensuite, j'appelle middleware auth.basic pour définir l'utilisateur. Et derniers rôles de middleware d'appel qui contrôle le rôle d'utilisateur par rapport à l'ensemble des rôles dans la demande, si elle a le rôle ou s'il est root, alors le résultat est vrai, sinon je renvoie une erreur:

return response([ 
      'error' => [ 
      'code' => 'INSUFFICIENT_ROLE', 
      'description' => 'You are not authorized to access this resource.' 
     ] 
     ], 401); 

Maintenant je l'erreur qui obtient toujours:

{"error":{"code":"INSUFFICIENT_ROLE","description":"You are not authorized to access this resource."}} 

C'est parce que le modèle utilisateur ne renvoie pas de rôle. Voir dans ma classe:

class User extends Model implements AuthenticatableContract, 
            AuthorizableContract, 
            CanResetPasswordContract 
{ 
    use Authenticatable, Authorizable, CanResetPassword; 

    /** 
    * The database table used by the model. 
    * 
    * @var string 
    */ 
    protected $table = 'users'; 

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

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

    //Comprobacion del rol del usuario 
    public function hasRole($roles) 
    { 
     $this->have_role = $this->getUserRole(); 
     // Check if the user is a root account 
     if($this->have_role->name == 'root') { 
      return true; 
     } 
     if(is_array($roles)){ 
      foreach($roles as $need_role){ 
       if($this->checkIfUserHasRole($need_role)) { 
        return true; 
       } 
      } 
     } else{ 
      return $this->checkIfUserHasRole($roles); 
     } 
     return false; 
    } 
    private function getUserRole() 
    { 
     return $this->role()->getResults(); 
    } 
    private function checkIfUserHasRole($need_role) 
    { 
     return (strtolower($need_role)==strtolower($this->have_role->name)) ? true : false; 
    } 

    //User relation with role 

    public function role(){ 
     return $this->belongsTo('App\Role'); 
    } 
} 

Quel est le problème?

Answer 1

Trouvé la solution !!!!! Merci Phorce pour me guider, vous m'avez donné les bases de l'idée. Je poste ici pour tous ceux qui en ont besoin. Comment obtenir l'authentification de rôle pour une API RESTful avec Laravel 5.

Explication. Dans le contrôleur de la route que j'appelle un constructeur pour le middleware, ajoutez d'abord les rôles d'attributs (les ensembles auxquels les rôles peuvent accéder à cette route) avec un objet de requête $ injecté. Ensuite, j'appelle middleware auth.basic pour demander l'utilisateur, puis un autre middleware pour vérifier les rôles. Ando c'est tout! Tout fonctionne.

Middleware:

<?php 

namespace App\Http\Middleware; 

use Closure; 

class CheckRole 
{ 
    /** 
    * Handle an incoming request. 
    * 
    * @param \Illuminate\Http\Request $request 
    * @param \Closure $next 
    * @return mixed 
    */ 
    public function handle($request, Closure $next) 
    { 
     //return $next($request); 

     // Get the required roles from the route 
     $roles = $this->getRequiredRoleForRoute($request->route()); 
     // Check if a role is required for the route, and 
     // if so, ensure that the user has that role. 
     //print "HasRole:".$request->user()->hasRole($roles)."."; 
     if($request->user()->hasRole($roles) || !$roles) 
     { 
      return $next($request); 
     } 
     return response([ 
      'error' => [ 
      'code' => 'INSUFFICIENT_ROLE', 
      'description' => 'You are not authorized to access this resource.' 
     ] 
     ], 401); 
    } 
    private function getRequiredRoleForRoute($route) 
    { 
     $actions = $route->getAction(); 
     //print "actinos:".print_r($actions); 
     return isset($actions['roles']) ? $actions['roles'] : null; 
    } 
} 

Modèle utilisateur

class User extends Model implements AuthenticatableContract, 
            AuthorizableContract, 
            CanResetPasswordContract 
{ 
    use Authenticatable, Authorizable, CanResetPassword; 

    /** 
    * The database table used by the model. 
    * 
    * @var string 
    */ 
    protected $table = 'users'; 

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

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

    protected $have_role; 
    protected $profile; 

    //Comprobacion del rol del usuario 
    public function hasRole($roles) 
    { 
     $this->have_role = $this->getUserRole(); 
     //$this->have_role = $this->role()->getResults(); 
     // Check if the user is a root account 
     if($this->have_role->nombre == 'root') { 
      return true; 
     } 
     if(is_array($roles)){ 

      foreach($roles as $need_role){ 
       if($this->checkIfUserHasRole($need_role)) { 
        return true; 
       } 
      } 
     } else{ 
      return $this->checkIfUserHasRole($roles); 
     } 
     return false; 
    } 
    private function getUserRole() 
    { 
     return $this->role()->getResults(); 
    } 
    private function checkIfUserHasRole($need_role) 
    { 
     if($need_role === $this->have_role->nombre){ 
     return true; 
     }else{ 
     return false; 
     } 
     //return (strtolower($need_role)==strtolower($this->have_role->name)) ? true : false; 
    } 

    //Relaciones de user 

    public function role(){ 
     return $this->belongsTo('App\Role'); 
    } 
} 

Routes:

Route::resource('perfiles','PerfilesUsuariocontroller',[ 'only'=>['index','show'] ]); 

Contrôleur méthode Constructor

public function __construct(Request $request) 
    { 
    $actions = $request->route()->setAction(['roles' => ['root', 'admin', 'seller']]); 

    $this->middleware('auth.basic'); 
    $this->middleware('roles'); 
    } 

Answer 2

De votre question, je me suis les suivantes:

Comment gérer auth middleware ...

Eh bien, supposons que vous avez deux intergiciels auth.basic, auth.admin

Vous pouvez alors vos routes sont comme:

Route::post('/api/getResponse', ['middleware' => 'auth', function() { 
    $var = "you have access to this route"; 
    return json_encode($var); 
}]); 

Ici, vous définissez si oui ou non, et qui a accès à cette partie. Dans ce cas, seules les personnes disposant de droits d'administrateur pourraient y avoir accès. Si, par exemple, vous ne disposez pas d'un middleware pour "admin", vous pouvez le créer en exécutant la commande artisan php artisan make:middleware admin, puis vous placez votre logique dans le fichier qui a été créé. Dans ce cas, la logique vérifiera si l'utilisateur (connecté) a des droits d'administrateur.

EDIT:

Comme vous l'avez indiqué dans votre réponse:

I dont user Route::post, I use Route::resource for handling RESTful API requests

Vous pouvez donc utiliser un groupe, voir:

Route::group(['middleware' => 'admin'], function() { 
    Route::resource('API_USER', 'API_USER_CONTROLLER'); 
}); 

Cela vous permettra d'utiliser votre admin groupe comme GROUPE et par conséquent, toutes vos routes qui ont accès peuvent entrer ici. Dans le passé, je viens de créer des groupes séparés pour tous mes groupes d'utilisateurs, à savoir admin aurait son propre, user aurait son propre et moderator aurait son propre. Mais, je crois que vous pouvez utiliser ce qui suit:

Route::group(['before' => 'auth|admin'], function() 
{ 

} 

Ce groupe se lit comme suit: should be open to auth users OR admin mais je ne l'ai pas complètement testé.