PHP Collection::contains方法代码示例

 /**
  * So here's the deal with permissions... Suppose we have code
  * like the following:
  * 
  * @if( $user->hasPermission('edit', 'Employee') )
  *     <li><a href="/editEmployees">Edit Employees</a></li>
  * @endif
  * 
  * Now suppose a user can edit a SUBSET of employees... We still
  * want to display this button, but within this button we need
  * to limit the employees shown. So we need two different actions:
  * 
  *     can you edit ANYTHING?
  *     what can you edit?
  * 
  * To prevent "what can you edit" from returning the entire
  * database in the event that you actually can edit everything,
  * it needs to somehow be condensed. Maybe a query string?
  * 
  * 
  * 
  */
 public function hasPermission($action, $model)
 {
     // First, is $model an instance? If so, get the class name
     if (is_string($model)) {
         $modelName = $model;
         $modelInstance = null;
     } else {
         $modelName = get_class($model);
         $modelInstance = $model;
     }
     // Now get ALL permissions for this action on this model
     $permissions = Permission::where(function ($query) use($action) {
         $query->orWhere('action', $action)->orWhere('action', 'all');
     })->where(function ($query) use($modelName) {
         $query->orWhere('model', 'like', $modelName)->orWhere('model', '*');
     })->get();
     // Now see if we have a matching role
     // To start, see if we have a previously cached list of roles:
     if ($this->roleParents == null) {
         // We start with a list of this user's roles...
         $this->roleParents = $this->roles;
         // Then we iteratively get all parents
         foreach ($this->roleParents as $role) {
             if ($role->parent != null) {
                 $this->roleParents->add($role->parent);
             }
         }
     }
     if ($this->roleChildren == null) {
         // We start with a list of this user's roles...
         $this->roleChildren = $this->roles;
         // Then we need to recursively get all children
         $children = new Collection();
         foreach ($this->roles as $role) {
             $this->roleChildren = $this->roleChildren->merge($this->getAllChildren($role));
         }
         $this->roleChildren = $this->roleChildren->unique();
     }
     foreach ($permissions as $permission) {
         if ($permission->role_id == 0 || $this->roleParents->contains($permission->role) || $this->roleChildren->contains($permission->role) && $permission->trickle) {
             // So the user has a role that can perform the action on this model
             if ($modelInstance == null) {
                 // If we're looking at the model as a whole, we good
                 return true;
             } else {
                 // If we're looking at a specific model, we need to check the domain
                 $domain = json_decode($permission->domain);
                 if (is_array($domain)) {
                     if ($this->confirmDomain($domain, $modelInstance)) {
                         return true;
                     }
                 } else {
                     return true;
                 }
             }
         }
     }
     // Failed to find a valid permission
     return false;
 }

 private function sortByLikes(Collection $collection, Collection $orderArray)
 {
     $sorted = new Collection();
     $orderArray->each(function ($orderElem) use($collection, $sorted) {
         if ($collection->contains($orderElem->likeable_id)) {
             $sorted->push($collection->find($orderElem->likeable_id));
         }
     });
     return $sorted;
 }

 /**
  * Get all permissions as collection.
  *
  * @return \Illuminate\Database\Eloquent\Collection
  */
 public function getPermissions()
 {
     if (!$this->permissions) {
         $rolePermissions = $this->rolePermissions()->get();
         $userPermissions = $this->userPermissions()->get();
         $deniedPermissions = new Collection();
         foreach ($userPermissions as $key => $permission) {
             if (!$permission->pivot->granted && $rolePermissions->contains($permission)) {
                 $deniedPermissions->push($permission);
             }
         }
         $permissions = $rolePermissions->merge($userPermissions);
         $this->permissions = $permissions->filter(function ($permission) use($deniedPermissions) {
             return !$deniedPermissions->contains($permission);
         });
     }
     return $this->permissions;
 }

 /**
  * Check if token is available
  *
  * @param string $tokenName
  *
  * @return bool
  */
 public function __isset($tokenName)
 {
     return (bool) $this->tokens->contains($tokenName);
 }

 public function permissions()
 {
     $permissions = new Collection();
     foreach ($this->roles as $role) {
         foreach ($role->permissions as $permission) {
             if (!$permissions->contains('id', $permission->id)) {
                 $permissions->add($permission);
             }
         }
     }
     return $permissions;
 }