wie eine hasMany Rolle Check in Laravel

Question

In meiner Website zuweisen

ich eine InitiatorController haben, die wie thi Gerade jetzt

class InitiatorController extends Controller 
{ 

use ExchangerateTrait; 
public function __construct(){ 

    $this->middleware('auth'); 
    $this->middleware('role:sales'); // replace 'collector' with whatever role you need. 
} 

public function getIndex(){ 


      return redirect('initiator/home'); 
} 

} 

sieht Nach der Authentifizierung ich überprüft habe, ob der Benutzer Rolle sales ist oder nicht Rollen-Middleware

Meine Rolle Middleware sieht so aus.

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

      if ($request->user()->role != $role){ 

        if($role=="collector" || $role=="admin") 
        return Redirect::to('/'); 
        if($role=="director" || $role=="admin") 
        return Redirect::to('/'); 
        if($role=="admin1" || $role=="admin") 
        return Redirect::to('/'); 
        if($role=="admin2" || $role=="admin") 
        return Redirect::to('/'); 
        if($role=="sales" || $role=="admin") 
        return Redirect::to('/'); 
        if($role=="developer" || $role=="admin") 
        return Redirect::to('/'); 


      } 

      return $next($request); 
     } 

} 

Jetzt habe ich eine Situation, in der Rolle director ist, aber er ist auch ein Verkaufsmann, Wie kann ich das angehen.

Erste Idee in Controller

wenn ich einige, wie wie diese kann ich

if(in_array ($request->user()->role,$roles)){ 
     //do some thing 
} 
else 
{ 
    //redirect to login 
} 

überprüfen wie

$roles = array('director,sales,teamlead'); 
$this->middleware('role:$roles'); 

und dann in Middle ware eine Reihe von Rollen an die Middleware etwas schicken

Answer 1

So habe ich eine Rollen-Middleware implementiert:

RoleMiddleware.php

class RoleMiddleware 
{ 
    /** 
    * Handle an incoming request. 
    * 
    * @param \Illuminate\Http\Request $request 
    * @param \Closure $next 
    * @return mixed 
    */ 
    public function handle($request, Closure $next) 
    { 
     $routeRoles = $this->getRolesForRoute($request->route()); 
     $user = $request->user(); 
     if (!$routeRoles || (isset($user) && $user->isPermitted($routeRoles))) { 
      return $next($request); 
     } 
     abort(401); 
    } 

    /** 
    * Function to get the roles of the requested route. 
    * 
    * @param \Illuminate\Routing\Route $route 
    * @return array|null 
    */ 
    public function getRolesForRoute($route) 
    { 
     $routeAction = $route->getAction(); 
     return isset($routeAction['roles']) ? $routeAction['roles'] : null; 
    } 
} 

routes.php

Route::get(
      '/post/delete/{pageId}', 
      [ 
       'as' => 'deleteNavigation', 
       'uses' => 'NavigationController@postDeleteNavigation', 
       'roles' => 'Administrator' 
      ] 
     ); 

Beachten Sie, dass 'Rollen' Array sein kann, oder eine Zeichenfolge

und dann in das User.php eloquent Modell des Benutzers:

/** 
* Function to check whether this user is permitted 
* a route or not. 
* 
* @param array|string|null $routeRoles Route roles. 
* 
* @return bool 
*/ 
public function isPermitted($routeRoles) 
{ 
    $routeRoles = strtolower($routeRoles); 
    if (empty($routeRoles)) { 
     return true; 
    } 

    $userRole = strtolower($this->role()->getResults()->name); 
    if (is_array($routeRoles)) { 
     foreach ($routeRoles as $routeRole) { 
      if ($routeRole == $userRole) { 
       return true; 
      } 
     } 
    } else { 
     if ($routeRoles == $userRole) { 
      return true; 
     } 
    } 

    return false; 
} 

/** 
* Define an inverse one-to-many relationship. 
* 
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo 
*/ 
public function role() 
{ 
    return $this->belongsTo(Role::class); 
} 

Ich weiß, es ist ein etwas anderes Protokoll ic als deins, aber es funktioniert gut für mich. Ich hoffe es hilft.

Answer 2

Ich bin mit L5.2, aber ich denke, es hat keinen Unterschied zwischen diesen. Wenn ich Ihre Frage richtig verstanden habe, können Sie mehrere Middleware params wie

$this->middleware('role:sales,leader'); //so on separated by commas 

Nur für den Fall einfügen verwenden Sie PHP> = 5.6, hat es neue coole Features, die ich häufig verwenden: Variable-length argument list. ...$roles

Für unter 5.6, denke ich func_get_args könnte helfen, auch

Dann etwas in Middleware (auch meine eigene gebrochene Logik Route Middleware Anpassung)

/** 
* Handle an incoming request. 
* 
* @param \Illuminate\Http\Request $request 
* @param \Closure $next 
* @param array $roles 
* @return mixed 
*/ 
public function handle($request, Closure $next, ...$roles) 
{ 
    $user = $request->user(); 

    if ($user && $this->isAllowed($user, $roles)) { 
     return $next($request); 
    } 

    return view('errors.403'); 
} 

---

Weiter mein gebrochenes Logik

sehen

/** 
* Check if current user role is allowed 
* 
* @param string  $user current requested user 
* @param null|array $roles 
* @return bool 
*/ 
protected function isAllowed($user, $roles) 
{ 
    $roles = $this->extractRoles($roles); 

    //Check for role exsistance 
    if (! $this->roleExists($roles)) { 
     return false; 
    } 

    //Override this check if user has super privillege 
    if ($user->role === $this->superRole()) { 
     return true; 
    } 

    foreach ($roles as $role) { 
     if (str_contains($role, $user->role)) { 
      return true; 
     } 
    } 

    return false; 
} 

/** 
* Convert given roles to an array 
* 
* @param null|array $roles 
* @return array 
*/ 
protected function extractRoles($roles) 
{ 
    $super = $this->superRole(); 
    foreach($roles as &$role) 
     $roles = strtolower($role); 

    //if no argument set on middleware return 
    //the super role 
    return count($roles) == 0 ? [$super] : $roles; 
} 

/** 
* Check if role is defined in config file 
* 
* @param null|array $roles 
* @return bool 
*/ 
protected function roleExists($roles) 
{ 
    $roleList = config('roles.roles'); 
    foreach($roleList as &$role) 
     $roleList = strtolower($role); 

    foreach ($roles as $role) { 
     if (in_array($roles, $roleList)) { 
      return true; 
     } 
    } 

    return false; 
} 

/** 
* Set the super privillege role 
* 
* @return string 
*/ 
public function superRole() 
{ 
    $super = config('roles.super'); 

    if (is_array($super)) { 
     $super = head($super); 
    } 

    return (string) strtolower($super); 
} 

Answer 3

Sie können Beziehungen im Modell als Funktion definieren und diese Funktion verwenden, um die Rolle hasMany zu überprüfen.

Wie in Laravel 5 docs gezeigt

https://laravel.com/docs/5.2/eloquent-relationships#one-to-many