UserAndLevel - Code Metrics - Inspection of "create helper function for fetching collections to..." - z1haze/laravel-acl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bd74a4...d9ea8c )

by Stephen

created 2017-03-06 14:49 UTC

UserAndLevel C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	477
Duplicated Lines	9.43 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
dl	45
loc	477
ccs	136
cts	136
cp	1
rs	6.433
c	0
b	0
f	0
wmc	57
lcom	1
cbo	2

28 Methods

Rating	Name	Duplication	Size	Complexity
A	addPermission()	0	4	1
A	addPermissions()	0	4	1
A	removePermission()	0	4	1
A	removePermissions()	0	4	1
A	syncPermissions()	0	4	1
A	isLevel()	0	6	2
A	hasLevel()	0	6	2
A	clearPermissions()	0	10	3
A	getPermissions()	0	4	1
A	getAllPermissions()	0	4	1
A	getInheritedPermissions()	0	4	1
A	getAvailablePermissions()	0	4	1
A	hasPermissionTo()	10	10	1
A	isLowerThan()	0	4	2
A	isHigherThan()	0	4	2
A	isEqualTo()	0	4	2
A	cachePull()	10	10	1
A	cacheGetPermissions()	0	4	1
A	cacheGetAllPermissions()	0	14	2
A	cacheGetInheritedPermissions()	0	15	3
A	cacheGetAvailablePermissions()	0	6	1
A	cacheHasPermissionTo()	0	14	4
B	modifyPermissions()	0	23	5
A	buildPermissionsArray()	0	18	4
A	addOrNegate()	0	10	3
A	remove()	11	12	3
A	sync()	14	15	3
A	getPermission()	0	16	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like UserAndLevel often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use UserAndLevel, and based on these observations, apply Extract Interface, too.

<?php

namespace z1haze\Acl\Traits;

use Illuminate\Support\Collection;
use ReflectionClass;
use z1haze\Acl\Exceptions\PermissionNotFoundException;
use Illuminate\Support\Facades\Cache;
use z1haze\Acl\Models\Level;
use z1haze\Acl\Models\Permission;

trait UserAndLevel
{
    /**
     * USER & LEVEL
     * Check if a model has a given level
     *
     * @param mixed level
     * @return bool
     */
    public function isLevel($level)
    {
        $level = aclGetALevel($level);

        return is_a($this, config('laravel-acl.level'), true) ? $this->name == $level->name : $this->level->name == $level->name;
class MyClass { }

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

    /**
     * USER & LEVEL
     * Check if a user has or has inherited
     * a given level
     *
     * @param $level
     * @return bool
     */
    public function hasLevel($level)
    {
        $level = aclGetALevel($level);

        return is_a($this, config('laravel-acl.level'), true) ? $this->rank <= $level->rank : $this->level->rank <= $level->rank;
class MyClass { }

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

    /**
     * USER & LEVEL
     * Add a single permission to a model
     *
     * @param $permission
     */
    public function addPermission($permission)
    {
        $this->modifyPermissions([$permission], 'add');
    }

    /**
     * USER & LEVEL
     * Add an array of permissions to a model
     *
     * @param $permissions
     */
    public function addPermissions(array $permissions)
    {
        $this->modifyPermissions($permissions, 'add');
    }

    /**
     * USER & LEVEL
     * Remove a permission from a model
     *
     * @param $permission
     */
    public function removePermission($permission)
    {
        $this->modifyPermissions([$permission], 'remove');
    }

    /**
     * USER & LEVEL
     * Remove an array of permissions objects or permission names (can be mixed)
     *
     * @param $permissions
     */
    public function removePermissions(array $permissions)
    {
        $this->modifyPermissions($permissions, 'remove');
    }

    /**
     * USER & LEVEL
     * Sync permissions on a model
     *
     * @param $permissions
     */
    public function syncPermissions(array $permissions)
    {
        $this->modifyPermissions($permissions, 'sync');
    }

    /**
     * USER & LEVEL
     * Clear permissions from a model
     */
    public function clearPermissions()
    {
        if (is_a($this, config('laravel-acl.user'), true)) {
            $this->permissions()->detach();

        }

        if (is_a($this, config('laravel-acl.level'), true)) {
            config('laravel-acl.permission', Permission::class)::whereLevelId($this->id)->update(['level_id' => null]);
class MyClass { }

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

    /**
     * USER & LEVEL
     * First try the cache to return the collection,
     * then fetch it from the database.
     *
     * See @cacheGetPermissions()
     *
     * @return \Illuminate\Support\Collection
     */
    public function getPermissions()
    {
        return $this->cachePull('cacheGetPermissions');
    }

    /**
     * USER & LEVEL
     * First try the cache to return the collection,
     * then fetch it from the database.
     *
     * See @cacheGetAllPermissions()
     *
     * @return \Illuminate\Support\Collection
     */
    public function getAllPermissions()
    {
        return $this->cachePull('cacheGetAllPermissions');
    }

    /**
     * USER & LEVEL
     * First try the cache to return the collection,
     * then fetch it from the database.
     *
     * See @cacheGetInheritedPermissions()
     *
     * @return \Illuminate\Support\Collection
     */
    public function getInheritedPermissions()
    {
        return $this->cachePull('cacheGetInheritedPermissions');
    }

    /**
     * USER & LEVEL
     * First try the cache to return the collection,
     * then fetch it from the database.
     *
     * See @cacheGetAvailablePermissions()
     *
     * @return \Illuminate\Support\Collection
     */
    public function getAvailablePermissions()
    {
        return $this->cachePull('cacheGetAvailablePermissions');
    }

    /**
     * USER & LEVEL
     * First try the cache to return the collection,
     * then fetch it from the database.
     *
     * See @cacheHasPermissionTo()
     *
     * @param $permission
     * @return bool
     */
    public function hasPermissionTo($permission)

    {
        return Cache::remember(
            'laravel-acl.hasPermissionTo_' . (new ReflectionClass($this))->getShortName() . '_' . $this->id . '_Permission_' . $permission,
            config('laravel-acl.cacheMinutes'),
            function() use ($permission) {
                return $this->cacheHasPermissionTo($permission);
            }
        );
    }

    /**
     * USER & LEVEL
     * Returns if a level is lower ranking than another level,
     * or if a user is lower ranking than another user.
     *
     * @param $other
     * @return bool
     */
    public function isLowerThan($other)
    {
        return is_a($this, config('laravel-acl.user'), true) ? $this->level->rank > $other->level->rank : $this->rank > $other->rank;
    }

    /**
     * USER & LEVEL
     * Returns if a level is higher ranking than another level,
     * or if a user is higher ranking than another user.
     *
     * @param $other
     * @return bool
     */
    public function isHigherThan($other)
    {
        return is_a($this, config('laravel-acl.user'), true) ? $this->level->rank < $other->level->rank : $this->rank < $other->rank;
    }

    /**
     * USER & LEVEL
     * Returns if a equal is lower ranking than another level,
     * or if a user is equal ranking than another user.
     *
     * @param $other
     * @return bool
     */
    public function isEqualTo($other)
    {
        return is_a($this, config('laravel-acl.user'), true) ? $this->level->rank == $other->level->rank : $this->rank == $other->rank;
    }


    /* ------------------------------------------------------------------------------------------------
     |  Other Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * USER & LEVEL
     * Pull the specific type requested from the cache
     *
     * @param $type
     * @return \Illuminate\Support\Collection
     */
    protected function cachePull($type)

    {
        return Cache::remember(
            'laravel-acl.' . lcfirst(substr($type, 5)) . 'For' . (new ReflectionClass($this))->getShortName() . '_' . $this->id,
            config('laravel-acl.cacheMinutes'),
            function() use ($type) {
                return $this->{$type}();
            }
        );
    }
    /**
     * USER & LEVEL
     * Return a collection of permissions
     * assigned to a user
     *
     * @return \Illuminate\Support\Collection
     */
    protected function cacheGetPermissions()
    {
        return $this->permissions;
class MyClass { }

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

    /**
     * USER & LEVEL
     * Return a collection of all permissions
     * associated to a user by direct or
     * inheritance
     *
     * @return \Illuminate\Support\Collection
     */
    protected function cacheGetAllPermissions()
    {
        $rank = is_a($this, config('laravel-acl.level'), true) ? $this->rank : $this->level->rank;

        $levels = config('laravel-acl.level', Level::class)::where('rank', '>=', $rank)->with('permissions')->get();

        $allPerms = new Collection();

        $levels->each(function($level) use (&$allPerms) {
            $allPerms = $allPerms->merge($level->permissions);
        });

        return $allPerms->merge($this->permissions)->unique('id');
    }

    /**
     * USER & LEVEL
     * Return a collection of permissions that
     * are inherited from a higher level
     *
     * @return \Illuminate\Support\Collection
     */
    protected function cacheGetInheritedPermissions()
    {
        $rank = is_a($this, config('laravel-acl.level'), true) ? $this->rank : $this->level->rank;

        $levels = is_a($this, config('laravel-acl.user'), true) ?
            config('laravel-acl.level', Level::class)::where('rank', '>=', $rank)->with('permissions')->get() : config('laravel-acl.level', Level::class)::where('rank', '>', $rank)->with('permissions')->get();

        $inheritedPerms = new Collection();

        $levels->each(function($level) use (&$inheritedPerms) {
            $inheritedPerms = $inheritedPerms->merge($level->permissions->load('level'));
        });

        return $inheritedPerms->unique('id');
    }

    /**
     * USER & LEVEL
     * Return a collection of permissions still able to be assigned
     * ie, not already inherited or explicitly assigned
     *
     * @return \Illuminate\Support\Collection
     */
    protected function cacheGetAvailablePermissions()
    {
        $allPerms = config('laravel-acl.permission', Permission::class)::with('level')->get();

        return $allPerms->diff($this->permissions);
    }

    /**
     * USER & LEVEL
     * Check if a model has permission to do something
     *
     * @param $permission
     * @return bool
     */
    protected function cacheHasPermissionTo($permission)
    {
        $permission = $this->getPermission($permission);

        if (is_a($this, config('laravel-acl.user'), true)) {
            $negatedPermissions = $this->permissions()->wherePivot('negated', true)->get();


            if ($this->getAllPermissions()->contains('id', $permission->id)) {
                return !$negatedPermissions->contains('id', $permission->id);
            }
        }

        return $this->getAllPermissions()->contains('id', $permission->id) || $this->getAllPermissions()->contains('name', '*');
    }

    /**
     * USER & LEVEL
     * Modify a given set of permissions, given the action to be taken
     *
     * @param $permissions
     * @param string $action
     */
    protected function modifyPermissions($permissions, $action)
    {
        Cache::forget('laravel-acl.getAvailablePermissionsFor' . (new ReflectionClass($this))->getShortName() . '_' . $this->id);
        Cache::forget('laravel-acl.getAllPermissionsFor' . (new ReflectionClass($this))->getShortName() . '_' . $this->id);
        Cache::forget('laravel-acl.getNegatedPermissionsForUser_' . $this->id);

        $permissionObjects = $this->buildPermissionsArray($permissions, $action);

        switch ($action) {
            case 'add':
                // Add and negate call the same method
            case 'negate':
                $this->addOrNegate($permissionObjects, $action);

                break;
            case 'remove':
                $this->remove($permissionObjects);
                break;
            case 'sync':
                $this->sync($permissionObjects);
            default:
                // Hopefully this never happens
        }
    }

    /**
     * USER & LEVEL
     * Helper function to build the array
     * for modifyPermissions
     *
     * @param $permissions
     * @param $action
     * @return array
     * @throws PermissionNotFoundException
     */
    protected function buildPermissionsArray($permissions, $action)
    {
        $permissionsObjects = [];

        foreach ($permissions as $permission) {
            $permission = $this->getPermission($permission);
            Cache::forget('laravel-acl.hasPermissionTo_' . (new ReflectionClass($this))->getShortName() . '_' . $this->id . '_Permission_' . $permission->id);

            if ($action == 'negate') {
                $permissionsObjects[$permission->id] = ['negated' => true];
            } else {
                is_a($this, config('laravel-acl.user')) ?
                    array_push($permissionsObjects, $permission->id) : array_push($permissionsObjects, $permission);
            }
        }

        return $permissionsObjects;
    }

    /**
     * USER & LEVEL
     * Helper function to handle adding or negating permissions
     *
     * @param $permissionObjects
     */
    protected function addOrNegate($permissionObjects)
    {
        if (is_a($this, config('laravel-acl.user'))) {
            $this->permissions()->attach($permissionObjects);

        }

        if (is_a($this, config('laravel-acl.level'))) {
            $this->permissions()->saveMany($permissionObjects);

        }
    }

    /**
     * USER & LEVEL
     * Helper function to handle removing permissions
     *
     * @param $permissionObjects
     */
    protected function remove($permissionObjects)

    {
        if (is_a($this, config('laravel-acl.user'))) {
            $this->permissions()->detach($permissionObjects);

        }

        if (is_a($this, config('laravel-acl.level'))) {
            config('laravel-acl.permission', Permission::class)::whereIn('id', array_map(function($permission) {
                return $permission->id;
            }, $permissionObjects))->update(['level_id' => null]);
        }
    }

    /**
     * USER & LEVEL
     * Help function to handle syncing permissions
     *
     * @param $permissionObjects
     */
    protected function sync($permissionObjects)

    {
        if (is_a($this, config('laravel-acl.user'))) {
            $this->permissions()->sync($permissionObjects);

        }

        if (is_a($this, config('laravel-acl.level'))) {
            $this->clearPermissions();

            config('laravel-acl.permission', Permission::class)::whereIn('id', array_map(function($permission) {
                return $permission->id;
            }, $permissionObjects))
                ->update(['level_id' => $this->id]);
        }
    }

    /**
     * USER & LEVEL
     * Helper function to get the permission whether it is the permission ID
     * or the permission name, or the permission object itself.
     *
     * @param $permission
     * @return \z1haze\Acl\Models\Permission
     * @throws PermissionNotFoundException
     */
    protected function getPermission($permission)
    {
        if (is_string($permission)) {
            $permission = config('laravel-acl.permission', Permission::class)::whereName($permission)->first();
        }

        if (is_int($permission)) {
            $permission = config('laravel-acl.permission', Permission::class)::find($permission);
        }

        if (!$permission) {
            throw new PermissionNotFoundException;
        }

        return $permission;
    }
}

z1haze / laravel-acl