Mrluke\Privileges\Manager

Complexity

Total Complexity

34

Size/Duplication

Total Lines	313
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	considerPermission()	0	22	5
A	__construct()	0	3	1
A	considerRestriction()	0	13	3
A	__get()	0	7	2
A	hasPermission()	0	5	1
A	regainPermission()	0	5	1
A	removeRole()	0	9	3
A	grantPermission()	0	9	2
A	getPermission()	0	5	1
A	getAuthorizableMigration()	0	21	3
A	hasRole()	0	3	1
A	getAuthorizableModel()	0	3	1
A	detectScope()	0	5	1
A	checkScopeAndLevel()	0	6	3
A	checkScope()	0	4	2
A	assignRole()	0	11	4

<?php

namespace Mrluke\Privileges;

use InvalidArgumentException;
use Mrluke\Configuration\Contracts\ArrayHost as Host;

The type Mrluke\Configuration\Contracts\ArrayHost was not found. Maybe you did not declare it correctly or list all dependencies?

use Mrluke\Configuration\Exceptions\ConfigurationException;

The type Mrluke\Configuration\Exceptions\ConfigurationException was not found. Maybe you did not declare it correctly or list all dependencies?

use Mrluke\Privileges\Contracts\Authorizable;
use Mrluke\Privileges\Contracts\Permission;
use Mrluke\Privileges\Contracts\Permitable;
use Mrluke\Privileges\Contracts\Role;

/**
 * Manager is a class that provides complex methods
 * to assign Authorizable to permissions and role.
 *
 * @author    Łukasz Sitnicki (mr-luke)
 * @link      http://github.com/mr-luke/privileges
 *
 * @category  Laravel
 * @package   mr-luke/privileges
 * @license   MIT
 * @version   1.0.0
 */
class Manager
{
    /**
     * Authorizable primary key name.
     *
     * @var string
     */
    protected $authKeyName;

    /**
     * Authorizable primary key type.
     *
     * @var string
     */
    protected $authKeyType;

    /**
     * Authorizable table name.
     *
     * @var string
     */
    protected $authTable;

    /**
     * Configuration instance.
     *
     * @var \Mrluke\Configuration\Contracts\ArrayHost
     */
    protected $config;

    public function __construct(Host $config)
    {
        $this->config = $config;
    }

    /**
     * Assign Authorizable to given role.
     *
     * @param  \Mrluke\Privileges\Contracts\Authorizable $auth
     * @param  mixed                                     $role
     * @return void
     */
    public function assignRole(Authorizable $auth, $role): void
    {
        if ($role instanceof Role) {
            $auth->roles()->syncWithoutDetaching([$role->id]);

Accessing id on the interface Mrluke\Privileges\Contracts\Role suggest that you code against a concrete implementation. How about adding an instanceof check?

        } elseif (is_integer($role)) {
            $auth->roles()->syncWithoutDetaching([$role]);
        } elseif (is_array($role)) {
            $auth->roles()->syncWithoutDetaching($role);
        } else {
            throw new InvalidArgumentException(
                sprintf('[role] parameter must be type of integer or instance of \Mrluke\Privileges\Contracts\Role. %s type given.', gettype($role))
            );
        }
    }

    /**
     * Return permission level based on personal's & role's permission.
     *
     * @param  \Mrluke\Privileges\Contracts\Authorizable $auth
     * @param  string                                    $scope
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function considerPermission(Authorizable $auth, string $scope): int
    {
        if ($personal = $this->getPermission($auth, $scope)) {
            // Personal permissions has priority
            // over role's ones.
            //
            return $personal->level;

Accessing level on the interface Mrluke\Privileges\Contracts\Permission suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        $general = 0;
        $auth->load('roles.permissions');

The method load() does not exist on Mrluke\Privileges\Contracts\Authorizable.

        foreach ($auth->roles as $r) {

Accessing roles on the interface Mrluke\Privileges\Contracts\Authorizable suggest that you code against a concrete implementation. How about adding an instanceof check?

            // Let's check if there's a given scope defined
            // as a permission in any of Authorizable roles.
            //
            if ($p = $this->getPermission($r, $scope)) {
                ($p->level < $general) ?: $general = $p->level;
            }
        }

        return $general;
    }

    /**
     * Return restrictions based on roles.
     *
     * @param  \Mrluke\Privileges\Contracts\Authorizable $auth
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function considerRestriction(Authorizable $auth): array
    {
        $restrictions = [];
        $level        = 0;

        $auth->load('roles.permissions');

        foreach ($auth->roles as $r) {

Accessing roles on the interface Mrluke\Privileges\Contracts\Authorizable suggest that you code against a concrete implementation. How about adding an instanceof check?

            // Let's check if there're restrictions for a roles.
            ($level < $r->level) ?: $restrictions = $r->restrictions;
        }

        return $restrictions;
    }

    /**
     * Detect which scope should be applied for given model.
     *
     * @param  string $model
     * @return string|null
     */
    public function detectScope(string $model)
    {
        return $this->config->get(
            'mapping.'.$model,
            $this->config->get('mapping_default')
        );
    }

    /**
     * Return Authorizable model reference.
     *
     * @return string
     */
    public function getAuthorizableModel(): string
    {
        return $this->config->get('authorizable');
    }

    /**
     * Return Authorizable migration config.
     *
     * @return array
     */
    public function getAuthorizableMigration(): array
    {
        if (is_null($this->authKeyName)) {

The condition is_null($this->authKeyName) is always false.

            $authorizableClass = $this->config->get('authorizable');
            $instance = new $authorizableClass;

            if (!$instance instanceof Model) {
                throw new ConfigurationException(
                    sprintf('An instance of [authorizable] should be \Illuminate\Databe\Eloquent\Model. %s given.', get_class($instance))
                );
            }

            $this->authKeyName = $instance->getKeyName();
            $this->authKeyType = $instance->getKeyType();
            $this->authTable   = $instance->getTable();
        }

        return [
            'key'   => $this->authKeyName,
            'type'  => $this->authKeyType,
            'table' => $this->authTable
        ];
    }

    /**
     * Return Permission for given scope.
     *
     * @param  \Mrluke\Privileges\Contracts\Permitable $subject
     * @param  string                                  $scope
     * @return \Mrluke\Privileges\Contracts\Permission|null
     *
     * @throws \InvalidArgumentException
     */
    public function getPermission(Permitable $subject, string $scope)
    {
        $this->checkScope($scope);

        return $subject->permissions->where('scope', $scope)->first();

Accessing permissions on the interface Mrluke\Privileges\Contracts\Permitable suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Grant or update premission for a Permitable.
     *
     * @param  \Mrluke\Privileges\Contracts\Permitable $subject
     * @param  string                                  $scope
     * @param  int                                     $level
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public function grantPermission(Permitable $subject, string $scope, int $level): void
    {
        $this->checkScopeAndLevel($scope, $level);

        $permission = $subject->permissions()->ofScope($scope)->first();

        $permission ? $permission->update(['level' => $level]) : $subject->permissions()->create([
            'scope' => $scope,
            'level' => $level
        ]);
    }

    /**
     * Determine if there's a given scope Permission for a Permitable.
     *
     * @param  \Mrluke\Privileges\Contracts\Permitable $subject
     * @param  string                                  $scope
     * @return bool
     *
     * @throws \InvalidArgumentException
     */
    public function hasPermission(Permitable $subject, string $scope): bool
    {
        $this->checkScope($scope);

        return $subject->permissions->where('scope', $scope)->exists();

Accessing permissions on the interface Mrluke\Privileges\Contracts\Permitable suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Determine if Permitable has given Role assigned.
     *
     * @param  \Mrluke\Privileges\Contracts\Permitable $subject
     * @param  mixed                                   $role
     * @return bool
     */
    public function hasRole(Permitable $subject, $role): bool
    {
        return $subject->roles->where('id', $role->id)->exists();

Accessing roles on the interface Mrluke\Privileges\Contracts\Permitable suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Regain permission for a Permitable.
     *
     * @param  \Mrluke\Privileges\Contracts\Permitable $subject
     * @param  string                                  $scope
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public function regainPermission(Permitable $subject, string $scope): void
    {
        $this->checkScope($scope);

        $subject->permissions()->ofScope($scope)->delete();
    }

    /**
     * Remove Authorizable's role.
     *
     * @param  \Mrluke\Privileges\Contracts\Authorizable $auth
     * @param  mixed                                     $role
     * @return void
     */
    public function removeRole(Authorizable $auth, $role): void
    {
        if ($role instanceof Role) {
            $auth->roles()->detach($role->id);

Accessing id on the interface Mrluke\Privileges\Contracts\Role suggest that you code against a concrete implementation. How about adding an instanceof check?

        } elseif (is_integer($role)) {
            $auth->roles()->detach($role);
        } else {
            throw new InvalidArgumentException(
                sprintf('[role] parameter must be type of integer or instance of \Mrluke\Privileges\Contracts\Role. %s type given.', gettype($role))
            );
        }
    }

    /**
     * Return class attributes or setting.
     *
     * @param  string $name
     * @return mixed
     */
    public function __get(string $name)
    {
        if (in_array($name, ['authKeyName', 'authKeyType', 'authTable'])) {
            return $this->{$name};
        }

        return $this->config->get($name, null);
    }

    /**
     * Check if the scope value.
     *
     * @param  string $scope
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    private function checkScope(string $scope): void
    {
        if (!in_array($scope, $this->config->get('scopes'))) {
            throw new InvalidArgumentException('Given [scope] is not allowed.');
        }
    }

    /**
     * Check if the scope & level values.
     *
     * @param  string $scope
     * @param  int    $level
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    private function checkScopeAndLevel(string $scope, int $level): void
    {
        $this->checkScope($scope);

        if ($level >= 0 && $level < 5) {
            throw new InvalidArgumentException('Given [level] must be in range of 0-4.');
        }
    }
}