cs\Permission

Complexity

Total Complexity

18

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	4
Bugs	2	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	cdb()	0	3	1
A	construct()	0	3	1
A	get()	0	18	4
A	add()	0	7	2
A	set()	0	7	2
B	del()	0	27	3
A	get_all()	0	18	4
A	del_all_cache()	0	4	1

<?php
/**
 * @package   CleverStyle CMS
 * @author    Nazar Mokrynskyi <nazar@mokrynskyi.com>
 * @copyright Copyright (c) 2013-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs;
use
	cs\Cache\Prefix;

/**
 * Class for permissions manipulating
 *
 * @method static $this instance($check = false)
 */
class Permission {
	use
		CRUD_helpers,
		Singleton;

	protected $data_model = [
		'id'    => 'int:0',
		'group' => 'text',
		'label' => 'text'
	];
	protected $table      = '[prefix]permissions';
	/**
	 * Array of all permissions for quick selecting
	 * @var array
	 */
	protected $permissions_table = [];
	/**
	 * @var Prefix
	 */
	protected $cache;
	/**
	 * Returns database index
	 *
	 * @return int
	 */
	protected function cdb () {
		return Config::instance()->module('System')->db('users');
	}
	protected function construct () {
		$this->cache = new Prefix('permissions');
	}
	/**
	 * Get permission data<br>
	 * If <b>$group</b> or/and <b>$label</b> parameter is specified, <b>$id</b> is ignored.
	 *
	 * @param int|null    $id
	 * @param null|string $group
	 * @param null|string $label
	 *
	 * @return array|false If only <b>$id</b> specified - result is array of permission data, in other cases result will be array of arrays of corresponding

Should the return type not be array|false|integer|string? Also, consider making the array more specific, something like array<String>, or String[].

	 *                     permissions data
	 */
	function get ($id = null, $group = null, $label = null) {
		if ($group !== null || $label !== null) {
			return $this->read(
				$this->search(

It seems like $this->search(array('group' => $group, 'label' => $label), 1, PHP_INT_MAX, 'id', true) ?: array() can also be of type array; however, cs\CRUD::read() does only seem to accept integer|array<integer,integer>|string|array<integer,string>, maybe add an additional type check?

					[
						'group' => $group,
						'label' => $label
					],
					1,
					PHP_INT_MAX,
					'id',
					true
				) ?: []
			);
		} else {
			return $this->read($id);
		}
	}
	/**
	 * Add permission
	 *
	 * @param string $group
	 * @param string $label
	 *
	 * @return false|int Group id or <b>false</b> on failure

Should the return type not be integer|string|false?

	 */
	function add ($group, $label) {
		$id = $this->create([$group, $label]);
		if ($id) {
			$this->del_all_cache();
		}
		return $id;
	}
	/**
	 * Set permission
	 *
	 * @param int    $id
	 * @param string $group
	 * @param string $label
	 *
	 * @return bool
	 */
	function set ($id, $group, $label) {
		$result = $this->update([$id, $group, $label]);
		if ($result) {
			$this->del_all_cache();
		}
		return $result;
	}
	/**
	 * Deletion of permission or array of permissions
	 *
	 * @param int|int[] $id
	 *
	 * @return bool
	 */
	function del ($id) {
		if (!$id) {
			return false;
		}
		$id = implode(',', (array)_int($id));
		if ($this->db_prime()->q(
			[
				"DELETE FROM `[prefix]permissions`
				WHERE `id` IN ($id)",
				"DELETE FROM `[prefix]users_permissions`
				WHERE `permission` IN ($id)",
				"DELETE FROM `[prefix]groups_permissions`
				WHERE `permission` IN ($id)"
			]
		)
		) {
			$Cache = $this->cache;
			unset(
				$Cache->users,
				$Cache->groups
			);
			$this->del_all_cache();
			return true;
		} else {
			return false;
		}
	}
	/**
	 * Returns array of all permissions grouped by permissions groups
	 *
	 * @return array Format of array: ['group']['label'] = <i>permission_id</i>
	 */
	function get_all () {
		if (empty($this->permissions_table)) {
			$this->permissions_table = $this->cache->get(

It seems like $this->cache->get('all', function () { $data = $this->read($this->search(array(), 1, PHP_INT_MAX, 'id', true) ?: array()); $all_permissions = array(); foreach ($data as $item) { $all_permissions[$item['group']][$item['label']] = $item['id']; } return $all_permissions; }) of type * is incompatible with the declared type array of property $permissions_table.

				'all',
				function () {
					$data            = $this->read(
						$this->search([], 1, PHP_INT_MAX, 'id', true) ?: []

It seems like $this->search(array(), 1, PHP_INT_MAX, 'id', true) ?: array() can also be of type array; however, cs\CRUD::read() does only seem to accept integer|array<integer,integer>|string|array<integer,string>, maybe add an additional type check?

					);
					$all_permissions = [];
					foreach ($data as $item) {

The expression $data of type array|false|integer|string is not guaranteed to be traversable. How about adding an additional type check?

						$all_permissions[$item['group']][$item['label']] = $item['id'];
					}
					return $all_permissions;
				}
			);
		}
		return $this->permissions_table;
	}
	/**
	 * Deletion of permission table (is used after adding, setting or deletion of permission)
	 */
	protected function del_all_cache () {
		$this->permissions_table = [];
		unset($this->cache->all);
	}
}