RoleMangerCommand::handle() - Code Metrics - mamikon/role-manager - Measure and Improve Code Quality continuously with Scrutinizer

RoleMangerCommand::handle() F
last analyzed 2017-04-13 01:05 UTC

↳ Parent: RoleMangerCommand

Complexity

Conditions	27
Paths	811

Size

Total Lines	98
Code Lines	58

Duplication

Lines	27
Ratio	27.55 %

Importance

Changes

Metric	Value
dl	27
loc	98
rs	2.1969
c	0
b	0
f	0
cc	27
eloc	58
nc	811
nop	0

How to fix Long Method Complexity

<?php

namespace Mamikon\RoleManager\Commands;

use Illuminate\Console\Command;
use Illuminate\Foundation\Auth\User;
use Mamikon\RoleManager\Models\Permissions;
use Mamikon\RoleManager\Models\Roles;

class RoleMangerCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'permissions:migrate';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Get Permissions And Roles from config, and add to db';

    /**
     * Create a new command instance.
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return void
     *
     * @throws \Exception
     */
    public function handle()
    {
        $permissions = config('roleManager.permissions');
        $roles = config('roleManager.roles');
        foreach ($permissions as $permissionName => $permission) {

            $permissionModel = new Permissions();
            if (empty($permissionName)) {
                throw new \Exception('Permission Name Required');
            }

            if (!$permissionModel->where('name', $permissionName)->first()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }


                $permissionModel->name = $permissionName;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

                if (isset($permission['description'])) {
                    $permissionModel->description = $permission['description'];
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                }
                if (isset($permission['class'])) {
                    $permissionModel->class = $permission['class'];
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                }
                if (isset($permission['method'])) {
                    $permissionModel->method = $permission['method'];

                }
                $permissionModel->save();
            }

        }
        foreach ($roles as $roleName => $role) {
            $roleModel = new Roles();
            if (empty($roleName)) {
                throw new \Exception('Role Name Required');
            }
            if (!$roleModel->where('name', $roleName)->first()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                $roleModel->name = $roleName;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                if (isset($role['description'])) {
                    $roleModel->description = $role['description'];
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                }
                $roleModel->save();
            }
        }

        $defaultRoles = config('roleManager.assignPermissionsToRole');
        foreach ($defaultRoles as $roleName => $permissionsList) {

            $roleModel = Roles::where('name', $roleName)
                ->with('permissions')->first();
            if ($roleModel) {

                if ($permissionsList == '*') {
                    foreach ($permissions as $permissionName => $permission) {

                        $permissionModel = Permissions::
                                        where('name', $permissionName)
                                        ->first();
                        if ($permissionModel) {
                            $checker = $roleModel->permissions
                                ->where('name', $permissionName)->first();
                            if (!$checker) {
                                $roleModel->permissions()->attach($permissionModel);
                            }
                        }
                    }

                } elseif (is_array($permissionsList)) {
                    foreach ($permissions as $permissionName) {


                        $permissionModel = Permissions::
                            where('name', $permissionName)->first();

                        if ($permissionModel) {

                            $checker = $roleModel->
                            permissions->where('name', $permissionName)->first();

                            if (!$checker) {
                                $roleModel->permissions()->attach($permissionModel);
                            }
                        }
                    }
                }
            }
        }

        $userAssignments = config('roleManager.assignRoleToUser');
        if (!empty($userAssignments) AND is_array($userAssignments)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            foreach ($userAssignments as $roleName => $userEmail) {
                $roleModel = Roles::where('name', $roleName)->first();
                if ($user = User::where('email', $userEmail)->first()
                    AND $roleModel
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                    AND !$roleModel->belongsToUser($user)
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                ) {
                    $roleModel->users()->attach($user);
                }
            }
        }
        echo "All permission Migrated Successfully";
    }
}


RoleMangerCommand::handle() F
last analyzed 2017-04-13 01:05 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

mamikon / role-manager

RoleMangerCommand::handle() F last analyzed 2017-04-13 01:05 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

RoleMangerCommand::handle() F
last analyzed 2017-04-13 01:05 UTC