Kaliop\eZMigrationBundle\Core\Executor\UserGroupManager

Complexity

Total Complexity

38

Size/Duplication

Total Lines	226
Duplicated Lines	5.75 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

88.04%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	create()	5	43	6
B	update()	0	55	9
A	delete()	0	12	2
D	matchUserGroups()	0	31	10
D	setReferences()	0	31	9
A	setSection()	8	8	1

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use Kaliop\eZMigrationBundle\Core\Matcher\UserGroupMatcher;
use Kaliop\eZMigrationBundle\API\Collection\UserGroupCollection;
use Kaliop\eZMigrationBundle\Core\Matcher\RoleMatcher;
use Kaliop\eZMigrationBundle\Core\Matcher\SectionMatcher;
use eZ\Publish\API\Repository\Values\Content\Content;

/**
 * Handles user-group migrations.
 */
class UserGroupManager extends RepositoryExecutor
{
    protected $supportedStepTypes = array('user_group');

    protected $userGroupMatcher;
    protected $roleMatcher;
    protected $sectionMatcher;

    public function __construct(UserGroupMatcher $userGroupMatcher, RoleMatcher $roleMatcher, SectionMatcher $sectionMatcher)
    {
        $this->userGroupMatcher = $userGroupMatcher;
        $this->roleMatcher = $roleMatcher;
        $this->sectionMatcher = $sectionMatcher;
    }

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

        $parentGroupId = $this->dsl['parent_group_id'];
        $parentGroupId = $this->referenceResolver->resolveReference($parentGroupId);
        $parentGroup = $this->userGroupMatcher->matchOneByKey($parentGroupId);

        $contentType = $this->repository->getContentTypeService()->loadContentTypeByIdentifier("user_group");

        $userGroupCreateStruct = $userService->newUserGroupCreateStruct($this->getLanguageCode(), $contentType);
        $userGroupCreateStruct->setField('name', $this->dsl['name']);

        if (isset($this->dsl['remote_id'])) {
            $userGroupCreateStruct->remoteId = $this->dsl['remote_id'];
        }

        if (isset($this->dsl['description'])) {
            $userGroupCreateStruct->setField('description', $this->dsl['description']);
        }

        if (isset($this->dsl['section'])) {
            $sectionKey = $this->referenceResolver->resolveReference($this->dsl['section']);
            $section = $this->sectionMatcher->matchOneByKey($sectionKey);
            $userGroupCreateStruct->sectionId = $section->id;
        }

        $userGroup = $userService->createUserGroup($userGroupCreateStruct, $parentGroup);

        if (isset($this->dsl['roles'])) {
            $roleService = $this->repository->getRoleService();
            // we support both Ids and Identifiers
            foreach ($this->dsl['roles'] as $roleId) {

This code seems to be duplicated across your project.

                $roleId = $this->referenceResolver->resolveReference($roleId);
                $role = $this->roleMatcher->matchOneByKey($roleId);
                $roleService->assignRoleToUserGroup($role, $userGroup);
            }
        }

        $this->setReferences($userGroup);

        return $userGroup;
    }

    /**
     * Method to handle the update operation of the migration instructions
     *
     * @throws \Exception When the ID of the user group is missing from the migration definition.
     */
    protected function update()
    {
        $userGroupCollection = $this->matchUserGroups('update');

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

        $userService = $this->repository->getUserService();
        $contentService = $this->repository->getContentService();

        foreach ($userGroupCollection as $key => $userGroup) {

The expression $userGroupCollection of type object<Kaliop\eZMigrationBundle\API\Collection\UserGroupCollection>|null is not guaranteed to be traversable. How about adding an additional type check?

            /** @var $updateStruct \eZ\Publish\API\Repository\Values\User\UserGroupUpdateStruct */
            $updateStruct = $userService->newUserGroupUpdateStruct();

            /** @var $contentUpdateStruct \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct */
            $contentUpdateStruct = $contentService->newContentUpdateStruct();

            if (isset($this->dsl['name'])) {
                $contentUpdateStruct->setField('name', $this->dsl['name']);
            }

            if (isset($this->dsl['remote_id'])) {
                $contentUpdateStruct->remoteId = $this->dsl['remote_id'];
            }

            if (isset($this->dsl['description'])) {
                $contentUpdateStruct->setField('description', $this->dsl['description']);
            }

            $updateStruct->contentUpdateStruct = $contentUpdateStruct;

            $userGroup = $userService->updateUserGroup($userGroup, $updateStruct);

            if (isset($this->dsl['parent_group_id'])) {
                $parentGroupId = $this->dsl['parent_group_id'];
                $parentGroupId = $this->referenceResolver->resolveReference($parentGroupId);
                $newParentGroup = $this->userGroupMatcher->matchOneByKey($parentGroupId);

                // Move group to new parent
                $userService->moveUserGroup($userGroup, $newParentGroup);
            }

            if (isset($this->dsl['section'])) {
                $this->setSection($userGroup, $this->dsl['section']);
            }

            $userGroupCollection[$key] = $userGroup;
        }

        $this->setReferences($userGroupCollection);

It seems like $userGroupCollection defined by $this->matchUserGroups('update') on line 83 can be null; however, Kaliop\eZMigrationBundle\Core\Executor\UserGroupManager::setReferences() does not accept null, maybe add an additional type check?

        return $userGroupCollection;
    }

    /**
     * Method to handle the delete operation of the migration instructions
     *
     * @throws \Exception When there are no groups specified for deletion.
     */
    protected function delete()
    {
        $userGroupCollection = $this->matchUserGroups('delete');

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

        foreach ($userGroupCollection as $userGroup) {

The expression $userGroupCollection of type object<Kaliop\eZMigrationBundle\API\Collection\UserGroupCollection>|null is not guaranteed to be traversable. How about adding an additional type check?

            $userService->deleteUserGroup($userGroup);
        }

        return $userGroupCollection;
    }

    /**
     * @param string $action
     * @return UserGroupCollection
     * @throws \Exception
     */
    protected function matchUserGroups($action)
    {
        if (!isset($this->dsl['id']) && !isset($this->dsl['group']) && !isset($this->dsl['match'])) {
            throw new \Exception("The id  of a group or a match condition is required to $action it.");
        }

        // Backwards compat
        if (!isset($this->dsl['match'])) {
            if (isset($this->dsl['id'])) {
                $this->dsl['match']['id'] = $this->dsl['id'];
            }
            if (isset($this->dsl['group'])) {
                $this->dsl['match']['email'] = $this->dsl['group'];
            }
        }

        $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->userGroupMatcher->match($match);
    }

    /**
     * Set references defined in the DSL for use in another step during the migrations.
     *
     * @throws \InvalidArgumentException When trying to set a reference to an unsupported attribute
     * @param \eZ\Publish\API\Repository\Values\User\UserGroup|UserGroupCollection $userGroup
     * @return boolean
     */
    protected function setReferences($userGroup)
    {
        if (!array_key_exists('references', $this->dsl)) {
            return false;
        }

        if ($userGroup instanceof UserGroupCollection) {
            if (count($userGroup) > 1) {
                throw new \InvalidArgumentException('UserGroup Manager does not support setting references for creating/updating of multiple groups');
            }
            $userGroup = reset($userGroup);
        }

        foreach ($this->dsl['references'] as $reference) {

            switch ($reference['attribute']) {
                case 'object_id':
                case 'content_id':
                case 'user_group_id':
                case 'id':
                    $value = $userGroup->id;
                    break;
                default:
                    throw new \InvalidArgumentException('User Group Manager does not support setting references for attribute ' . $reference['attribute']);
            }

            $this->referenceResolver->addReference($reference['identifier'], $value);

It seems like you code against a concrete implementation and not the interface Kaliop\eZMigrationBundle\API\ReferenceResolverInterface as the method addReference() does only exist in the following implementations of said interface: Kaliop\eZMigrationBundle\Core\ReferenceResolver\ChainPrefixResolver, Kaliop\eZMigrationBundle\Core\ReferenceResolver\ChainRegexpResolver, Kaliop\eZMigrationBundle\Core\ReferenceResolver\ChainResolver, Kaliop\eZMigrationBundle\Core\ReferenceResolver\CustomReferenceResolver.

        }

        return true;
    }

    protected function setSection(Content $content, $sectionKey)

This method seems to be duplicated in your project.

    {
        $sectionKey = $this->referenceResolver->resolveReference($sectionKey);
        $section = $this->sectionMatcher->matchOneByKey($sectionKey);

        $sectionService = $this->repository->getSectionService();
        $sectionService->assignSection($content->contentInfo, $section);
    }
}