RoleManager::create() - Code Metrics - Inspection of "Extend GenerateCommand to generate migration for e..." - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#91)

unknown

created 2017-01-25 14:11 UTC

RoleManager::create() B

↳ Parent: RoleManager

Complexity

Conditions	5
Paths	8

Size

Total Lines	27
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	5.0488

Importance

Changes

Metric	Value
dl	0
loc	27
ccs	14
cts	16
cp	0.875
rs	8.439
c	0
b	0
f	0
cc	5
eloc	14
nc	8
nop	0
crap	5.0488

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use eZ\Publish\API\Repository\Values\User\Role;
use eZ\Publish\API\Repository\RoleService;
use eZ\Publish\API\Repository\UserService;
use eZ\Publish\API\Repository\Exceptions\InvalidArgumentException;
use Kaliop\eZMigrationBundle\API\Collection\RoleCollection;
use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;
use Kaliop\eZMigrationBundle\Core\Helper\LimitationConverter;
use Kaliop\eZMigrationBundle\Core\Matcher\RoleMatcher;

/**
 * Handles the role migration definitions.
 */
class RoleManager extends RepositoryExecutor implements MigrationGeneratorInterface
{
    protected $supportedStepTypes = array('role');

    protected $limitationConverter;
    protected $roleMatcher;

    public function __construct(RoleMatcher $roleMatcher, LimitationConverter $limitationConverter)
    {
        $this->roleMatcher = $roleMatcher;
        $this->limitationConverter = $limitationConverter;
    }

    /**
     * Method to handle the create operation of the migration instructions
     */
    protected function create()
    {
        $roleService = $this->repository->getRoleService();
        $userService = $this->repository->getUserService();

        $roleCreateStruct = $roleService->newRoleCreateStruct($this->dsl['name']);

        // Publish new role
        $role = $roleService->createRole($roleCreateStruct);
        if (is_callable(array($roleService, 'publishRoleDraft'))) {
            $roleService->publishRoleDraft($role);

        }

        if (isset($this->dsl['policies'])) {
            foreach($this->dsl['policies'] as $key => $ymlPolicy) {
                $this->addPolicy($role, $roleService, $ymlPolicy);
            }
        }

        if (isset($this->dsl['assign'])) {
            $this->assignRole($role, $roleService, $userService, $this->dsl['assign']);
        }

        $this->setReferences($role);

        return $role;
    }

    /**
     * Method to handle the update operation of the migration instructions
     */
    protected function update()
    {
        $roleCollection = $this->matchRoles('update');

        if (count($roleCollection) > 1 && isset($this->dsl['references'])) {
            throw new \Exception("Can not execute Role update because multiple roles match, and a references section is specified in the dsl. References can be set when only 1 role matches");
        }

        if (count($roleCollection) > 1 && isset($this->dsl['new_name'])) {
            throw new \Exception("Can not execute Role update because multiple roles match, and a new_name is specified in the dsl.");
        }

        $roleService = $this->repository->getRoleService();
        $userService = $this->repository->getUserService();

        /** @var \eZ\Publish\API\Repository\Values\User\Role $role */
        foreach ($roleCollection as $key => $role) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }

            // Updating role name
            if (isset($this->dsl['new_name'])) {
                $update = $roleService->newRoleUpdateStruct();
                $update->identifier = $this->dsl['new_name'];
                $role = $roleService->updateRole($role, $update);
            }

            if (isset($this->dsl['policies'])) {
                $ymlPolicies = $this->dsl['policies'];

                // Removing all policies so we can add them back.
                // TODO: Check and update policies instead of remove and add.
                $policies = $role->getPolicies();
                foreach($policies as $policy) {
                    $roleService->deletePolicy($policy);
                }

                foreach($ymlPolicies as $ymlPolicy) {
                    $this->addPolicy($role, $roleService, $ymlPolicy);
                }
            }

            if (isset($this->dsl['assign'])) {
                $this->assignRole($role, $roleService, $userService, $this->dsl['assign']);
            }

            $roleCollection[$key] = $role;
        }

        $this->setReferences($roleCollection);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        return $roleCollection;
    }

    /**
     * Method to handle the delete operation of the migration instructions
     */
    protected function delete()
    {
        $roleCollection = $this->matchRoles('delete');

        $roleService = $this->repository->getRoleService();

        foreach ($roleCollection as $role) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $roleService->deleteRole($role);
        }

        return $roleCollection;
    }

    /**
     * @param string $action
     * @return RoleCollection
     * @throws \Exception
     */
    protected function matchRoles($action)

    {
        if (!isset($this->dsl['name']) && !isset($this->dsl['match'])) {
            throw new \Exception("The name of a role or a match condition is required to $action it.");
        }

        // Backwards compat
        if (!isset($this->dsl['match'])) {
            $this->dsl['match'] = array('identifier' => $this->dsl['name']);
        }

        $match = $this->dsl['match'];

        // convert the references passed in the match
        foreach ($match as $condition => $values) {
            if (is_array($values)) {
                foreach ($values as $position => $value) {
                    $match[$condition][$position] = $this->referenceResolver->resolveReference($value);
                }
            } else {
                $match[$condition] = $this->referenceResolver->resolveReference($values);
            }
        }

        return $this->roleMatcher->match($match);
    }

    /**
     * Set references to object attributes to be retrieved later.
     *
     * The Role Manager currently support setting references to role_ids.
     *
     * @param \eZ\Publish\API\Repository\Values\User\Role|RoleCollection $role
     * @throws \InvalidArgumentException When trying to assign a reference to an unsupported attribute
     * @return boolean
     */
    protected function setReferences($role)

    {
        if (!array_key_exists('references', $this->dsl)) {
            return false;
        }

        if ($role instanceof RoleCollection) {
            if (count($role) > 1) {
                throw new \InvalidArgumentException('Role Manager does not support setting references for creating/updating of multiple roles');
            }
            $role = reset($role);
        }

        foreach ($this->dsl['references'] as $reference) {
            switch ($reference['attribute']) {
                case 'role_id':
                case 'id':
                    $value = $role->id;
                    break;
                case 'identifier':
                case 'role_identifier':
                    $value = $role->identifier;
                    break;
                default:
                    throw new \InvalidArgumentException('Role Manager does not support setting references for attribute ' . $reference['attribute']);
            }

            $this->referenceResolver->addReference($reference['identifier'], $value);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        return true;
    }

    /**
     * Create a new Limitation object based on the type and value in the $limitation array.
     *
     * <pre>
     * $limitation = array(
     *  'identifier' => Type of the limitation
     *  'values' => array(Values to base the limitation on)
     * )
     * </pre>
     *
     * @param \eZ\Publish\API\Repository\RoleService $roleService
     * @param array $limitation
     * @return \eZ\Publish\API\Repository\Values\User\Limitation
     */
    private function createLimitation(RoleService $roleService, array $limitation)
    {
        $limitationType = $roleService->getLimitationType($limitation['identifier']);

        $limitationValue = is_array($limitation['values']) ? $limitation['values'] : array($limitation['values']);

        foreach($limitationValue as $id => $value) {
            $limitationValue[$id] = $this->referenceResolver->resolveReference($value);
        }
        $limitationValue = $this->limitationConverter->resolveLimitationValue($limitation['identifier'], $limitationValue);
        return $limitationType->buildValue($limitationValue);
    }

    /**
     * Assign a role to users and groups in the assignment array.
     *
     * <pre>
     * $assignments = array(
     *      array(
     *          'type' => 'user',
     *          'ids' => array(user ids),
     *          'limitation' => array(limitations)
     *      )
     * )
     * </pre>
     *
     * @param \eZ\Publish\API\Repository\Values\User\Role $role
     * @param \eZ\Publish\API\Repository\RoleService $roleService
     * @param \eZ\Publish\API\Repository\UserService $userService
     * @param array $assignments
     */
    private function assignRole(Role $role, RoleService $roleService, UserService $userService, array $assignments)
    {
        foreach ($assignments as $assign) {
            switch ($assign['type']) {
                case 'user':

                    foreach ($assign['ids'] as $userId) {
                        $userId = $this->referenceResolver->resolveReference($userId);

                        $user = $userService->loadUser($userId);

                        if (!isset($assign['limitations'])) {
                            $roleService->assignRoleToUser($role, $user);
                        } else {
                            foreach ($assign['limitations'] as $limitation) {
                                $limitationObject = $this->createLimitation($roleService, $limitation);
                                $roleService->assignRoleToUser($role, $user, $limitationObject);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                            }
                        }
                    }
                    break;
                case 'group':

                    foreach ($assign['ids'] as $groupId) {
                        $groupId = $this->referenceResolver->resolveReference($groupId);

                        $group = $userService->loadUserGroup($groupId);

                        if (!isset($assign['limitations'])) {
                            // q: why are we swallowing exceptions here ?
                            //try {
                                $roleService->assignRoleToUserGroup($role, $group);
                            //} catch (InvalidArgumentException $e) {}

                        } else {
                            foreach ($assign['limitations'] as $limitation) {
                                $limitationObject = $this->createLimitation($roleService, $limitation);
                                // q: why are we swallowing exceptions here ?
                                //try {
                                    $roleService->assignRoleToUserGroup($role, $group, $limitationObject);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                                //} catch (InvalidArgumentException $e) {}

                            }
                        }
                    }
                    break;
            }
        }
    }

    /**
     * Add new policies to the $role Role.
     *
     * @param \eZ\Publish\API\Repository\Values\User\Role $role
     * @param \eZ\Publish\API\Repository\RoleService $roleService
     * @param array $policy
     */
    private function addPolicy(Role $role, RoleService $roleService, array $policy)
    {
        $policyCreateStruct = $roleService->newPolicyCreateStruct($policy['module'], $policy['function']);

        if (array_key_exists('limitations', $policy)) {
            foreach ($policy['limitations'] as $limitation) {
                $limitationObject = $this->createLimitation($roleService, $limitation);
                $policyCreateStruct->addLimitation($limitationObject);
            }
        }

        $roleService->addPolicy($role, $policyCreateStruct);
    }

    /**
     * @param string $identifier
     * @param string $mode
     * @throws \Exception
     * @return array
     */
    public function generateMigration($identifier, $mode)
    {
        $this->loginUser(self::ADMIN_USER_ID);

        /** @var \eZ\Publish\API\Repository\Values\User\Role $role */
        $role = $this->roleMatcher->matchOneByKey($identifier);

        $policies = array();
        /** @var \eZ\Publish\API\Repository\Values\User\Policy $policy */
        foreach ($role->getPolicies() as $policy) {
            $limitations = array();

            /** @var \eZ\Publish\API\Repository\Values\User\Limitation $limitation */
            foreach ($policy->getLimitations() as $limitation) {
                $limitations[] = $this->limitationConverter->getLimitationArrayWithIdentifiers($limitation);
            }

            $policies[] = array(
                'module' => $policy->module,
                'function' => $policy->function,
                'limitations' => $limitations
            );
        }

        $data = array(
            'type' => 'role',
            'mode' => $mode
        );

        switch ($mode) {
            case 'create':
                $data = array_merge(
                    $data,
                    array(
                        'name' => $identifier
                    )
                );
                break;
            case 'update':
                $data = array_merge(
                    $data,
                    array(
                        'match' => array(
                            'identifier' => $identifier
                        )
                    )
                );
                break;
            default:
                throw new \Exception("Executor 'content_type' doesn't support mode '$mode'");
        }

        $data = array_merge(
            $data,
            array(
                'policies' => $policies
            )
        );

        return array($data);
    }
}


1		<?php
2
3		namespace Kaliop\eZMigrationBundle\Core\Executor;
4
5		use eZ\Publish\API\Repository\Values\User\Role;
6		use eZ\Publish\API\Repository\RoleService;
7		use eZ\Publish\API\Repository\UserService;
8		use eZ\Publish\API\Repository\Exceptions\InvalidArgumentException;
9		use Kaliop\eZMigrationBundle\API\Collection\RoleCollection;
10		use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;
11		use Kaliop\eZMigrationBundle\Core\Helper\LimitationConverter;
12		use Kaliop\eZMigrationBundle\Core\Matcher\RoleMatcher;
13
14		/**
15		* Handles the role migration definitions.
16		*/
17		class RoleManager extends RepositoryExecutor implements MigrationGeneratorInterface
18		{
19		protected $supportedStepTypes = array('role');
20	20
21		protected $limitationConverter;
22	20	protected $roleMatcher;
23	20
24		public function __construct(RoleMatcher $roleMatcher, LimitationConverter $limitationConverter)
25		{
26		$this->roleMatcher = $roleMatcher;
27		$this->limitationConverter = $limitationConverter;
28	1	}
29
30	1	/**
31	1	* Method to handle the create operation of the migration instructions
32		*/
33	1	protected function create()
34		{
35		$roleService = $this->repository->getRoleService();
36	1	$userService = $this->repository->getUserService();
37
38	1	$roleCreateStruct = $roleService->newRoleCreateStruct($this->dsl['name']);
39	1
40	1	// Publish new role

kaliop-uk / ezmigrationbundle

Pull Request — master (#91)

RoleManager::create() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like