modules\rbac\models\Role

Complexity

Total Complexity

35

Size/Duplication

Total Lines	308
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	validateUniqueName()	0	7	3
A	scenarios()	0	8	1
A	attributeLabels()	0	9	1
A	getRolePermissions()	0	11	3
A	getItemsPermissions()	0	12	3
A	rules()	0	28	1
A	tree()	0	8	1
A	getRoleChildArray()	0	10	3
A	getRoleItemsArray()	0	10	3
A	getRolesByRole()	0	11	3
A	processCheckRoleName()	0	9	3
A	getPermissionsByRole()	0	11	3
A	getRoleChild()	0	4	1
A	rolesArray()	0	8	1
A	getItemsRoles()	0	12	3
A	getChildren()	0	4	1
A	getRoles()	0	4	1

<?php

namespace modules\rbac\models;

use Yii;
use yii\base\Model;
use yii\rbac\Item;
use modules\rbac\Module;

/**
 * Class Role
 * @package modules\rbac\models
 *
 * @property-read Role[] $roles
 * @property-read array $roleItemsArray
 * @property-read array $rolePermissions
 * @property-read Item[] $children
 * @property-read array $roleChildArray
 * @property-read Role[] $roleChild
 */
class Role extends Model
{
    // константы ролей
    const ROLE_SUPER_ADMIN = 'super_admin';
    const ROLE_SUPER_ADMIN_DESCRIPTION = 'Super Administrator';

    const ROLE_ADMIN = 'admin';
    const ROLE_ADMIN_DESCRIPTION = 'Administrator';

    const ROLE_MANAGER = 'manager';
    const ROLE_MANAGER_DESCRIPTION = 'FileStateForm';

    const ROLE_EDITOR = 'editor';
    const ROLE_EDITOR_DESCRIPTION = 'Editor';

    const ROLE_DEFAULT = 'user';
    const ROLE_DEFAULT_DESCRIPTION = 'User';

    // сценарии
    const SCENARIO_CREATE = 'create';
    const SCENARIO_UPDATE = 'update';

    public $name;
    public $description;
    public $isNewRecord = false;

    /** @var  array $rolesByRole Наследуемые роли */
    public $rolesByRole;
    /** @var  array $itemsRoles Доступные роли */
    public $itemsRoles;

    /** @var  array $permissionsByRole Установленные разрешения для роли */
    public $permissionsByRole;
    /** @var array $itemsPermissions Разрешения */
    public $itemsPermissions;

    /**
     * @inheritdoc
     * @return array
     */
    public function rules()
    {
        return [
            ['name', 'required', 'on' => self::SCENARIO_CREATE],
            ['name', 'string', 'max' => 64, 'on' => self::SCENARIO_CREATE],
            [
                'name',
                'match',
                'pattern' => '#^[\w_-]+$#i',
                'message' => Module::translate(
                    'module',
                    'It is allowed to use the Latin alphabet, numbers, dashes and underscores.(A-z,0-1,-,_)'
                ),
                'on' => self::SCENARIO_CREATE
            ],
            [
                'name',
                'validateUniqueName',
                'skipOnEmpty' => false,
                'skipOnError' => false,
                'on' => self::SCENARIO_CREATE
            ],

            [['description'], 'string'],
            [
                ['rolesByRole', 'itemsRoles', 'permissionsByRole', 'itemsPermissions'],
                'required',
                'on' => self::SCENARIO_UPDATE
            ]
        ];
    }

    /**
     * @param string $attribute
     */
    public function validateUniqueName($attribute)
    {
        if (!$attribute) {
            $this->addError($attribute, Module::translate('module', 'Enter name role.'));
        }
        if (!$this->hasErrors()) {
            $this->processCheckRoleName($attribute);
        }
    }

    /**
     * Tree roles
     * @return array
     */
    public static function tree()
    {
        return [
            self::ROLE_SUPER_ADMIN => [
                self::ROLE_ADMIN => [
                    self::ROLE_MANAGER => [
                        self::ROLE_EDITOR => [
                            self::ROLE_DEFAULT
                        ]
                    ]
                ]
            ]
        ];
    }

    /**
     * @param string $attribute
     * @return mixed
     */
    public function processCheckRoleName($attribute)
    {
        if (!empty($this->name)) {
            $auth = Yii::$app->authManager;
            if ($auth->getRole($this->name)) {
                $this->addError($attribute, Module::translate('module', 'This name is already taken.'));
            }
        }
        return $attribute;
    }

    /**
     * @return array
     */
    public function scenarios()
    {
        $scenarios = parent::scenarios();
        $scenarios[self::SCENARIO_CREATE] = ['name', 'description'];
        $scenarios[self::SCENARIO_UPDATE] = [
            'name', 'description', 'rolesByRole', 'itemsRoles', 'permissionsByRole', 'itemsPermissions'
        ];
        return $scenarios;
    }

    /**
     * @inheritdoc
     * @return array
     */
    public function attributeLabels()
    {
        return [
            'name' => Module::translate('module', 'Name'),
            'description' => Module::translate('module', 'Description'),
            'rolesByRole' => Module::translate('module', 'Roles by role'),
            'itemsRoles' => Module::translate('module', 'Items roles'),
            'permissionsByRole' => Module::translate('module', 'Permissions by role'),
            'itemsPermissions' => Module::translate('module', 'Items permissions')
        ];
    }

    /**
     * @return array
     */
    public static function rolesArray()
    {
        return [
            self::ROLE_SUPER_ADMIN => self::ROLE_SUPER_ADMIN_DESCRIPTION,
            self::ROLE_ADMIN => self::ROLE_ADMIN_DESCRIPTION,
            self::ROLE_MANAGER => self::ROLE_MANAGER_DESCRIPTION,
            self::ROLE_EDITOR => self::ROLE_EDITOR_DESCRIPTION,
            self::ROLE_DEFAULT => self::ROLE_DEFAULT_DESCRIPTION
        ];
    }

    /**
     * Возвращает установленные разрешения для роли
     * @return array
     */
    public function getPermissionsByRole()
    {
        $auth = Yii::$app->authManager;
        $perm = $auth->getPermissionsByRole($this->name);
        $arr = [];
        foreach ($perm as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->name . ' (' . $value->description . ')';
            }
        }
        return $arr;
    }

    /**
     * Возвращает все разрешения
     * @return array
     */
    public function getItemsPermissions()
    {
        $auth = Yii::$app->authManager;
        $perm = $auth->getPermissions();
        $arr = [];
        foreach ($perm as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->name . ' (' . $value->description . ')';
            }
        }
        $permByRole = $this->getPermissionsByRole();
        return array_diff($arr, $permByRole);
    }

    /**
     * Возвращает дочерние роли
     * @return array
     */
    public function getRolesByRole()
    {
        $auth = Yii::$app->authManager;
        $roles = $auth->getChildRoles($this->name);
        $arr = [];
        foreach ($roles as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->name . ' (' . $value->description . ')';
            }
        }
        return $arr;
    }

    /**
     * Возвращает все роли
     * @return array
     */
    public function getItemsRoles()
    {
        $auth = Yii::$app->authManager;
        $roles = $auth->getRoles();
        $arr = [];
        foreach ($roles as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->name . ' (' . $value->description . ')';
            }
        }
        $rolesByRole = $this->getRolesByRole();
        return array_diff($arr, $rolesByRole);
    }

    /**
     * @return \yii\rbac\Role[]
     */
    public function getRoleChild()
    {
        $auth = Yii::$app->authManager;
        return $auth->getChildRoles($this->name);
    }

    /**
     * Возвращает массив дочерних ролей
     * @return array
     */
    public function getRoleChildArray()
    {
        $roles = $this->getRoleChild();
        $arr = [];
        foreach ($roles as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->description;
            }
        }
        return $arr;
    }

    /**
     * Получаем все роли
     * @return \yii\rbac\Role[]
     */
    public function getRoles()
    {
        $auth = Yii::$app->authManager;
        return $auth->getRoles();
    }

    /**
     * Возвращает массив ролей
     * @return array
     */
    public function getRoleItemsArray()
    {
        $roles = $this->getRoles();
        $arr = [];
        foreach ($roles as $value) {
            if ($value->name !== $this->name) {
                $arr[$value->name] = $value->description;
            }
        }
        return $arr;
    }

    /**
     *
     * @return array
     */
    public function getRolePermissions()
    {
        $auth = Yii::$app->authManager;
        $children = $auth->getChildren($this->name);
        $perm = [];
        foreach ($children as $key => $child) {
            if ($child->type === 2) {
                $perm[$key] = $child;
            }
        }
        return $perm;
    }

    /**
     * Все дети
     * @return Item[]
     */
    public function getChildren()
    {
        $auth = Yii::$app->authManager;
        return $auth->getChildren($this->name);
    }
}