Slince\CakePermission\Model\Entity\RoleTrait

Complexity

Total Complexity

13

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	givePermission()	0	11	3
A	revokePermission()	0	9	2
A	revokeAllPermissions()	0	7	1
A	getAllPermissions()	0	10	1
A	find()	0	4	1
A	create()	0	14	3
A	findOrCreate()	0	9	2

<?php
/**
 * CakePHP permission handling library
 * @author Tao <taosikai@yeah.net>
 */
namespace Slince\CakePermission\Model\Entity;

use Cake\Cache\Cache;
use Cake\Datasource\Exception\RecordNotFoundException;
use Cake\ORM\Query;
use Cake\Utility\Text;
use Slince\CakePermission\Constants;
use Slince\CakePermission\Exception\InvalidArgumentException;
use Slince\CakePermission\Model\Table\PermissionsTableTrait;
use Slince\CakePermission\TableFactory;

trait RoleTrait
{
    use HasPermissionTrait;

    /**
     * Gives the permission or an array of permissions
     * @param string|Permission|array $permission
     * @return bool
     */
    public function givePermission($permission)
    {
        $permissions = is_array($permission) ? $permission : [$permission];
        $permissions = array_map(function($permission){
            return is_string($permission) ? Permission::find($permission) : $permission;
        }, $permissions);
        $this->set('permissions', $permissions);

It seems like set() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $result = TableFactory::getRoleModel()->save($this) !== false;
        PermissionsTableTrait::refreshCache($this->id);

The property id does not exist. Did you maybe forget to declare it?

        return $result;
    }

    /**
     * Revokes the permissions of the role
     * @param $permission
     * @return
     */
    public function revokePermission($permission)
    {
        if (is_string($permission)) {
            $permission = Permission::find($permission);
        }
        $result = TableFactory::getRoleModel()->association('Permissions')->unlink($this, [$permission]);
        PermissionsTableTrait::refreshCache($this->id);
        return $result;
    }

    /**
     * Revokes all permissions of the role
     * @return boolean
     */
    public function revokeAllPermissions()
    {
        $result = TableFactory::getRoleModel()->association('Permissions')->unlink($this,
            $this->getAllPermissions());
        PermissionsTableTrait::refreshCache($this->id);
        return $result;
    }

    /**
     * Gets all permissions for the role
     * @return Permission[]
     */
    public function getAllPermissions()
    {
        $primaryKey = TableFactory::getRoleModel()->getPrimaryKey();
        $id = $this->get($primaryKey);

It seems like get() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return Cache::remember(sprintf(Constants::CACHE_PERMISSIONS, $id), function() use ($id){
            return TableFactory::getPermissionModel()->find()->matching('Roles', function(Query $query) use ($id){
                return $query->where(['Roles.id' => $id]);
            })->toArray();
        });
    }

    /**
     * Finds the role by its name
     * @param string $name
     * @return RoleTrait

The return type RoleTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public static function find($name)
    {
        return TableFactory::getRoleModel()->findByName($name)->firstOrFail();
    }

    /**
     * Creates a role
     * @param $arguments
     * @return RoleTrait

The return type RoleTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public static function create($arguments)
    {
        if (is_string($arguments)) {
            $arguments = [
                'name' => $arguments
            ];
        }
        $arguments['slug'] = Text::slug($arguments['name']);
        $role = TableFactory::getRoleModel()->newEntity($arguments, ['validate' => 'permission']);
        if (TableFactory::getRoleModel()->save($role) === false) {
            throw new InvalidArgumentException('Failed to create the role');
        }
        return $role;
    }

    /**
     * Finds the role, if it does not exists, the role will be created
     * @param $name
     * @return RoleTrait

The return type RoleTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public static function findOrCreate($name)
    {
        try {
            $role = static::find($name);
        } catch (RecordNotFoundException $exception) {
            $role = static::create($name);
        }
        return $role;
    }
}