HasRoles::convertToRoleModels() - Code Metrics - Inspection of "add convertToRoleModels and convertToPermissionMod..." - mostafamaklad/laravel-permission-mongodb - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — v1.3 (5b46b6)

by Mostafa Abd El-Salam

created 2017-09-10 10:39 UTC

HasRoles::convertToRoleModels() A

↳ Parent: Project

Complexity

Conditions	3
Paths	4

Size

Total Lines	16
Code Lines	8

Duplication

Lines	16
Ratio	100 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes

Metric	Value
dl	16
loc	16
ccs	8
cts	8
cp	1
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	8
nc	4
nop	1
crap	3

<?php
declare(strict_types=1);

namespace Maklad\Permission\Traits;

use Illuminate\Support\Collection;
use Jenssegers\Mongodb\Eloquent\Builder;
use Jenssegers\Mongodb\Eloquent\Model;
use Jenssegers\Mongodb\Relations\BelongsToMany;
use Maklad\Permission\Contracts\PermissionInterface as Permission;
use Maklad\Permission\Contracts\RoleInterface as Role;

/**
 * Trait HasRoles
 * @package Maklad\Permission\Traits
 */
trait HasRoles
{
    use HasPermissions;

    public static function bootHasRoles()
    {
        static::deleting(function (Model $model) {
            foreach ($model->roles as $role) {
                $role->users()->detach($model);
            }
            foreach ($model->permissions as $permission) {
                $permission->users()->detach($model);
            }
        });
    }

    /**
     * A model may have multiple roles.
     */
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(\config('permission.models.role'))->withTimestamps();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * A model may have multiple direct permissions.
     */
    public function permissions(): BelongsToMany
    {
        return $this->belongsToMany(\config('permission.models.permission'))->withTimestamps();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Scope the model query to certain roles only.
     *
     * @param Builder $query
     * @param string|array|Role|Collection $roles
     *
     * @return Builder
     */
    public function scopeRole(Builder $query, $roles): Builder
    {
        $roles = $this->convertToRoleModels($roles);

        return $query->whereIn('role_ids', $roles->pluck('_id'));
    }

    /**
     * Scope the model query to certain permissions only.
     *
     * @param Builder $query
     * @param string|array|Permission|Collection $permissions
     *
     * @return Builder
     */
    public function scopePermission(Builder $query, $permissions): Builder
    {
        $permissions = $this->convertToPermissionModels($permissions);

        $roles = \collect([]);

        foreach ($permissions as $permission) {
            $roles = $roles->merge($permission->roles);
        }
        $roles = $roles->unique();

        return $query->orWhereIn('permission_ids', $permissions->pluck('_id'))
                     ->orWhereIn('role_ids', $roles->pluck('_id'));
    }

    /**
     * Assign the given role to the model.
     *
     * @param array|string|Role ...$roles
     *
     * @return $this
     */
    public function assignRole(...$roles)

    {
        $roles = \collect($roles)
            ->flatten()
            ->map(function ($role) {
                return $this->getStoredRole($role);
            })
            ->each(function ($role) {
                $this->ensureModelSharesGuard($role);
            })
            ->all();

        $this->roles()->saveMany($roles);
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}

        $this->forgetCachedPermissions();

        return $this;
    }

    /**
     * Revoke the given role from the model.
     *
     * @param string|Role $role
     */
    public function removeRole($role)
    {
        $this->roles()->detach($this->getStoredRole($role));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Remove all current roles and set the given ones.
     *
     * @param array ...$roles
     *
     * @return $this
     */
    public function syncRoles(...$roles)
    {
        $this->roles()->detach();

        return $this->assignRole($roles);
    }

    /**
     * Determine if the model has (one of) the given role(s).
     *
     * @param string|array|Role|\Illuminate\Support\Collection $roles
     *
     * @return bool
     */
    public function hasRole($roles): bool
    {
        if (\is_string($roles) && false !== \strpos($roles, '|')) {

            $roles = \explode('|', $roles);
        }

        if (\is_string($roles)) {
            return $this->roles->contains('name', $roles);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        if ($roles instanceof Role) {
            return $this->roles->contains('id', $roles->id);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        if (\is_array($roles)) {
            foreach ($roles as $role) {
                if ($this->hasRole($role)) {
                    return true;
                }
            }

            return false;
        }

        return $roles->intersect($this->roles)->isNotEmpty();
    }

    /**
     * Determine if the model has any of the given role(s).
     *
     * @param string|array|Role|\Illuminate\Support\Collection $roles
     *
     * @return bool
     */
    public function hasAnyRole($roles): bool
    {
        return $this->hasRole($roles);
    }

    /**
     * Determine if the model has all of the given role(s).
     *
     * @param string|Role|\Illuminate\Support\Collection $roles
     *
     * @return bool
     */
    public function hasAllRoles($roles): bool
    {
        if (\is_string($roles) && false !== strpos($roles, '|')) {

            $roles = \explode('|', $roles);
        }

        if (\is_string($roles)) {
            return $this->roles->contains('name', $roles);
        }

        if ($roles instanceof Role) {
            return $this->roles->contains('id', $roles->id);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        $roles = \collect()->make($roles)->map(function ($role) {
            return $role instanceof Role ? $role->name : $role;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        });

        return $roles->intersect($this->roles->pluck('name')) == $roles;
    }

    /**
     * Determine if the model may perform the given permission.
     *
     * @param string|Permission $permission
     * @param string|null $guardName
     *
     * @return bool
     */
    public function hasPermissionTo($permission, $guardName = null): bool
    {
        if (\is_string($permission)) {
            $permission = \app(Permission::class)->findByName(
                $permission,
                $guardName ?? $this->getDefaultGuardName()
            );
        }

        return $this->hasDirectPermission($permission) || $this->hasPermissionViaRole($permission);
    }

    /**
     * Determine if the model has any of the given permissions.
     *
     * @param array ...$permissions
     *
     * @return bool
     */
    public function hasAnyPermission(...$permissions): bool
    {
        if (\is_array($permissions[0])) {
            $permissions = $permissions[0];
        }

        foreach ($permissions as $permission) {
            if ($this->hasPermissionTo($permission)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Determine if the model has, via roles, the given permission.
     *
     * @param Permission $permission
     *
     * @return bool
     */
    protected function hasPermissionViaRole(Permission $permission): bool
    {
        return $this->hasRole($permission->roles);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
    }

    /**
     * Determine if the model has the given permission.
     *
     * @param string|Permission $permission
     *
     * @return bool
     */
    public function hasDirectPermission($permission): bool
    {
        if (\is_string($permission)) {
            $permission = \app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
        }

        return $this->permissions->contains('id', $permission->id);
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Return all permissions the directory coupled to the model.
     */
    public function getDirectPermissions(): Collection
    {
        return $this->permissions;
    }

    /**
     * Return all the permissions the model has via roles.
     */
    public function getPermissionsViaRoles(): Collection
    {
        return $this->load('roles', 'roles.permissions')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->roles->flatMap(function (Role $role) {
                return $role->permissions;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            })->sort()->values();
    }

    /**
     * Return all the permissions the model has, both directly and via roles.
     */
    public function getAllPermissions(): Collection
    {
        return $this->permissions
            ->merge($this->getPermissionsViaRoles())
            ->sort()
            ->values();
    }

    /**
     * Return Role object
     *
     * @param String|Role $role role name
     *
     * @return Role
     */
    protected function getStoredRole($role): Role
    {
        if (\is_string($role)) {
            return \app(Role::class)->findByName($role, $this->getDefaultGuardName());
        }

        return $role;
    }

    /**
     * Return a collection of role names associated with this user.
     *
     * @return Collection
     */
    public function getRoleNames(): Collection
    {
        return $this->roles->pluck('name');
    }


    /**
     * Return a collection of permission names associated with this user.
     *
     * @return Collection
     */
    public function getPermissionNames(): Collection
    {
        return $this->getAllPermissions()->pluck('name');
    }

    /**
     * Convert to Role Models
     *
     * @param $roles
     *
     * @return Collection
     */
    private function convertToRoleModels($roles): Collection

    {
        if (\is_array($roles)) {
            $roles = \collect($roles);
        }

        if (! $roles instanceof Collection) {
            $roles = \collect([$roles]);
        }

        $roles = $roles->map(function ($role) {
            return $this->getStoredRole($role);
        });

        return $roles;
    }
}


Branch — v1.3 (5b46b6)

HasRoles::convertToRoleModels() A

Complexity

Size

Duplication

Code Coverage

Importance

1 path for user data to reach this point

General Strategies to prevent injection

1 path for user data to reach this point

General Strategies to prevent injection

9 paths for user data to reach this point

Used in path-read context

General Strategies to prevent injection

9 paths for user data to reach this point

Used in path-write context

General Strategies to prevent injection

9 paths for user data to reach this point

Used in unserialized context

Preventing Object Injection Attacks

General Strategies to prevent injection

9 paths for user data to reach this point

Used in code-execution context

General Strategies to prevent injection

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1		<?php
2		declare(strict_types=1);
3
4		namespace Maklad\Permission\Traits;
5
6		use Illuminate\Support\Collection;
7		use Jenssegers\Mongodb\Eloquent\Builder;
8		use Jenssegers\Mongodb\Eloquent\Model;
9		use Jenssegers\Mongodb\Relations\BelongsToMany;
10		use Maklad\Permission\Contracts\PermissionInterface as Permission;
11		use Maklad\Permission\Contracts\RoleInterface as Role;
12
13		/**
14		* Trait HasRoles
15		* @package Maklad\Permission\Traits
16		*/
17		trait HasRoles
18		{
19		use HasPermissions;
20
21		public static function bootHasRoles()
22		{
23	110	static::deleting(function (Model $model) {
24	2	foreach ($model->roles as $role) {
25	1	$role->users()->detach($model);
26		}
27	2	foreach ($model->permissions as $permission) {
28	1	$permission->users()->detach($model);
29		}
30	110	});
31	110	}
32
33		/**
34		* A model may have multiple roles.
35		*/
36	63	public function roles(): BelongsToMany
37		{
38	63	return $this->belongsToMany(\config('permission.models.role'))->withTimestamps();
		0 ignored issues – show Bug introduced 2017-09-01 16:42 UTC by Report Bug Copy Issue Report It seems like `belongsToMany()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history... Security Code Execution introduced 2017-09-07 17:23 UTC by Report Bug Copy Issue Report `\config('permission.models.role')` can contain request data and is used in code execution context(s) leading to a potential security vulnerability. 1 path for user data to reach this point Read from `$_SERVER,` and `$server` is assigned in vendor/src/Illuminate/Foundation/Bootstrap/SetRequestForConsole.php on line 22 Data is passed through array_replace() in vendor/Request.php on line 360 Data is passed through call_user_func() in vendor/Request.php on line 2019 `\Illuminate\Http\Request::create($uri, 'GET', array(), array(), array(), $server)` is passed to Container::instance() in vendor/src/Illuminate/Foundation/Bootstrap/SetRequestForConsole.php on line 31 Container::$instances is assigned in vendor/src/Illuminate/Container/Container.php on line 371 Tainted property Container::$instances is read in vendor/src/Illuminate/Container/Container.php on line 597 Container::resolve() returns tainted data in vendor/src/Illuminate/Container/Container.php on line 575 Container::make() returns tainted data in vendor/src/Illuminate/Foundation/helpers.php on line 106 app() returns tainted data in vendor/src/Illuminate/Foundation/helpers.php on line 262 config() returns tainted data in src/Traits/HasRoles.php on line 38 General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
39		}

mostafamaklad / laravel-permission-mongodb

Branch — v1.3 (5b46b6)

HasRoles::convertToRoleModels() A

Complexity

Size

Duplication

Code Coverage

Importance

1 path for user data to reach this point

General Strategies to prevent injection

1 path for user data to reach this point

General Strategies to prevent injection

9 paths for user data to reach this point

Used in path-read context

General Strategies to prevent injection

9 paths for user data to reach this point

Used in path-write context

General Strategies to prevent injection

9 paths for user data to reach this point

Used in unserialized context

Preventing Object Injection Attacks

General Strategies to prevent injection

9 paths for user data to reach this point

Used in code-execution context

General Strategies to prevent injection

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like