Micro\Auth\DbAcl

Complexity

Total Complexity

19

Size/Duplication

Total Lines	226
Duplicated Lines	12.39 %

Coupling/Cohesion

Components	0
Dependencies	2

11 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	22	28	4
A	check()	0	20	1
A	createRole()	3	6	2
A	createPermission()	3	6	2
A	deletePermission()	0	4	1
A	deleteRole()	0	7	2
A	rolePerms()	0	10	1
A	assignRolePermission()	0	4	1
A	revokeRolePermission()	0	4	1
A	grantPrivilege()	0	8	2
A	forbidPrivilege()	0	8	2

<?php /** MicroDbACL */

namespace Micro\Auth;

use Micro\Mvc\Models\Query;

/**
 * Database ACL class file.
 *
 * ACL security logic with DB
 *
 * @author Oleg Lunegov <testuser@mail.linpax.org>
 * @link https://github.com/lugnsk/micro
 * @copyright Copyright &copy; 2013 Oleg Lunegov
 * @license /LICENSE
 * @package Micro
 * @subpackage Auth
 * @version 1.0
 * @since 1.0
 */
class DbAcl extends Acl
{
    /**
     * Constructor DB acl
     *
     * @access public
     *
     * @param array $params config array
     *
     * @result void
     */
    public function __construct(array $params = [])
    {
        parent::__construct($params);

        $tables = $this->container->db->listTables();

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        if (empty($tables['acl_role'])) {

This code seems to be duplicated across your project.

            $this->container->db->createTable('acl_role', [

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

                '`id` int(10) unsigned NOT NULL AUTO_INCREMENT',
                '`name` varchar(255) NOT NULL',
                'PRIMARY KEY (`id`)'
            ], 'ENGINE=MyISAM DEFAULT CHARSET=utf8');
        }
        if (empty($tables['acl_perm'])) {

This code seems to be duplicated across your project.

            $this->container->db->createTable('acl_perm', [

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

                '`id` int(10) unsigned NOT NULL AUTO_INCREMENT',
                '`name` varchar(255) NOT NULL',
                'PRIMARY KEY (`id`)'
            ], 'ENGINE=MyISAM DEFAULT CHARSET=utf8');
        }
        if (empty($tables['acl_role_perm'])) {

This code seems to be duplicated across your project.

            $this->container->db->createTable('acl_role_perm', [

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

                '`id` int(10) unsigned NOT NULL AUTO_INCREMENT',
                '`role` int(11) unsigned DEFAULT NOT NULL',
                '`perm` int(11) unsigned DEFAULT NOT NULL',
                'PRIMARY KEY (`id`)'
            ], 'ENGINE=MyISAM DEFAULT CHARSET=utf8');
        }
    }

    /**
     * Check user access to permission
     *
     * @access public
     *
     * @param integer $userId user id
     * @param string $permission checked permission
     * @param array $data for compatible, not used!
     *
     * @return bool
     * @throws \Micro\base\Exception
     */
    public function check($userId, $permission, array $data = [])
    {
        $query = new Query($this->container->db);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        $query->select = '*';
        $query->table = '`acl_user` AS `au`';

        $query->addJoin('`acl_perm` AS  `ap`', '`ap`.`id` =  `au`.`perm`');
        $query->addJoin('`acl_role_perm` AS  `arp`', '`arp`.`role` =  `au`.`role`');
        $query->addJoin('`acl_perm` AS  `ap1`', '`ap1`.`id` =  `arp`.`perm`');

        $query->addWhere('`au`.`user`=' . $userId);
        $query->addWhere('`ap`.`name`=:perm OR `ap1`.`name`=:perm');

        $query->limit = 1;

        $query->params = [':perm' => $permission];
        $query->single = true;

        return (bool)$query->run();
    }

    /**
     * Create new role
     *
     * @access public
     *
     * @param string $name role name
     *
     * @return void
     */
    public function createRole($name)
    {
        if (!$this->container->db->exists('acl_role', ['name' => $name])) {

This code seems to be duplicated across your project.

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $this->container->db->insert('acl_role', ['name' => $name]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }

    /**
     * Create new permission
     *
     * @access public
     *
     * @param string $name permission name
     *
     * @return void
     */
    public function createPermission($name)
    {
        if (!$this->container->db->exists('acl_role', ['name' => $name])) {

This code seems to be duplicated across your project.

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $this->container->db->insert('acl_role', ['name' => $name]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }

    /**
     * Delete permission by name
     *
     * @access public
     *
     * @param string $name permission name
     *
     * @return void
     */
    public function deletePermission($name)
    {
        $this->container->db->delete('acl_perm', ['name' => $name]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Delete role by name
     *
     * @access public
     *
     * @param string $name role name
     *
     * @return void
     * @throws \Micro\base\Exception
     */
    public function deleteRole($name)
    {
        foreach ($this->rolePerms($name) AS $perm) {
            $this->container->db->delete('acl_role_perm', ['id' => $perm['perm']]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        $this->container->db->delete('acl_role', ['name' => $name]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Get role perms
     *
     * @access public
     *
     * @param string $role role name
     *
     * @return array
     * @throws \Micro\base\Exception
     */
    protected function rolePerms($role)
    {
        $query = new Query($this->container->db);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        $query->select = '*';
        $query->table = 'acl_role_perm';
        $query->addWhere('role=' . $role);
        $query->single = false;

        return $query->run();
    }

    /**
     * Assign role permission
     *
     * @access public
     *
     * @param string $role role name
     * @param string $permission permission name
     *
     * @return void
     */
    public function assignRolePermission($role, $permission)
    {
        $this->container->db->insert('acl_role_perm', ['role' => $role, 'perm' => $permission]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Revoke role permission
     *
     * @access public
     *
     * @param string $role role name
     * @param string $permission permission name
     *
     * @return void
     */
    public function revokeRolePermission($role, $permission)
    {
        $this->container->db->delete('acl_role_perm', ['role' => $role, 'perm' => $permission]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * Grant privilege to user
     *
     * @access public
     *
     * @param integer $userId user ID
     * @param integer $privilege privilege ID
     * @param boolean $asRole as role?
     *
     * @return void
     */
    public function grantPrivilege($userId, $privilege = null, $asRole = true)
    {
        if ($asRole) {
            $this->container->db->insert('acl_user', ['user' => $userId, 'role' => $privilege]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        } else {
            $this->container->db->insert('acl_user', ['user' => $userId, 'perm' => $privilege]);

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }

    /**
     * Forbid privilege
     *
     * @access public
     *
     * @param integer $userId user ID
     * @param integer $privilege privilege ID
     * @param bool $asRole as role?
     */
    public function forbidPrivilege($userId, $privilege = null, $asRole = true)
    {
        if ($asRole) {
            $this->container->db->delete('acl_user', '`user`="' . $userId . '" AND `role`="' . $privilege . '"');

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        } else {
            $this->container->db->delete('acl_user', '`user`="' . $userId . '" AND `perm`="' . $privilege . '"');

Accessing db on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }
}