Kaliop\eZMigrationBundle\Core\Executor\ObjectStateGroupManager

Complexity

Total Complexity

40

Size/Duplication

Total Lines	249
Duplicated Lines	34.54 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	delete()	0	12	2
B	matchObjectStateGroups()	21	21	5
A	__construct()	0	4	1
B	create()	5	28	6
C	update()	37	37	11
C	setReferences()	0	25	7
C	generateMigration()	21	72	8

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use Kaliop\eZMigrationBundle\API\Collection\ObjectStateGroupCollection;

use Kaliop\eZMigrationBundle\Core\Matcher\ObjectStateGroupMatcher;
use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;

class ObjectStateGroupManager extends RepositoryExecutor implements MigrationGeneratorInterface
{
    /**
     * @var array
     */
    protected $supportedStepTypes = array('object_state_group');

    /**
     * @var ObjectStateGroupMatcher
     */
    protected $objectStateGroupMatcher;

    /**
     * @param ObjectStateGroupMatcher $objectStateGroupMatcher
     */
    public function __construct(ObjectStateGroupMatcher $objectStateGroupMatcher)
    {
        $this->objectStateGroupMatcher = $objectStateGroupMatcher;
    }

    /**
     * Handle the create step of object state group migrations
     *
     * @todo add support for flexible defaultLanguageCode
     */
    protected function create()
    {
        foreach (array('names', 'identifier') as $key) {

This code seems to be duplicated across your project.

            if (!isset($this->dsl[$key])) {
                throw new \Exception("The '$key' key is missing in a object state group creation definition");
            }
        }

        $objectStateService = $this->repository->getObjectStateService();

        $objectStateGroupCreateStruct = $objectStateService->newObjectStateGroupCreateStruct($this->dsl['identifier']);
        $objectStateGroupCreateStruct->defaultLanguageCode = self::DEFAULT_LANGUAGE_CODE;

        foreach ($this->dsl['names'] as $languageCode => $name) {
            $objectStateGroupCreateStruct->names[$languageCode] = $name;
        }
        if (isset($this->dsl['descriptions'])) {
            foreach ($this->dsl['descriptions'] as $languageCode => $description) {
                $objectStateGroupCreateStruct->descriptions[$languageCode] = $description;
            }
        }

        $objectStateGroup = $objectStateService->createObjectStateGroup($objectStateGroupCreateStruct);

        $this->setReferences($objectStateGroup);

        return $objectStateGroup;
    }

    /**
     * Handle the update step of object state group migrations
     *
     * @todo add support for defaultLanguageCode
     */
    protected function update()

This method seems to be duplicated in your project.

    {
        $objectStateService = $this->repository->getObjectStateService();

        $groupsCollection = $this->matchObjectStateGroups('update');

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

        if (count($groupsCollection) > 1 && isset($this->dsl['identifier'])) {
            throw new \Exception("Can not execute Object State Group update because multiple groups match, and an identifier is specified in the dsl.");
        }

        foreach ($groupsCollection as $objectStateGroup) {

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

            $objectStateGroupUpdateStruct = $objectStateService->newObjectStateGroupUpdateStruct();

            if (isset($this->dsl['identifier'])) {
                $objectStateGroupUpdateStruct->identifier = $this->dsl['identifier'];
            }
            if (isset($this->dsl['names'])) {
                foreach ($this->dsl['names'] as $languageCode => $name) {
                    $objectStateGroupUpdateStruct->names[$languageCode] = $name;
                }
            }
            if (isset($this->dsl['descriptions'])) {
                foreach ($this->dsl['descriptions'] as $languageCode => $description) {
                    $objectStateGroupUpdateStruct->descriptions[$languageCode] = $description;
                }
            }
            $objectStateGroup = $objectStateService->updateObjectStateGroup($objectStateGroup, $objectStateGroupUpdateStruct);

            $this->setReferences($objectStateGroup);
        }

        return $groupsCollection;
    }

    /**
     * Handle the delete step of object state group migrations
     */
    protected function delete()
    {
        $groupsCollection = $this->matchObjectStateGroups('delete');

        $objectStateService = $this->repository->getObjectStateService();

        foreach ($groupsCollection as $objectStateGroup) {

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

            $objectStateService->deleteObjectStateGroup($objectStateGroup);
        }

        return $groupsCollection;
    }

    /**
     * @param string $action
     * @return ObjectStateGroupCollection
     * @throws \Exception
     */
    protected function matchObjectStateGroups($action)

This method seems to be duplicated in your project.

    {
        if (!isset($this->dsl['match'])) {
            throw new \Exception("A match condition is required to $action an ObjectStateGroup.");
        }

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

    /**
     * {@inheritdoc}
     * @param \eZ\Publish\API\Repository\Values\ObjectState\ObjectStateGroup $objectStateGroup
     */
    protected function setReferences($objectStateGroup)
    {
        if (!array_key_exists('references', $this->dsl)) {
            return false;
        }

        foreach ($this->dsl['references'] as $reference) {
            switch ($reference['attribute']) {
                case 'object_state_group_id':
                case 'id':
                    $value = $objectStateGroup->id;
                    break;
                case 'object_state_group_identifier':
                case 'identifier':
                    $value = $objectStateGroup->id;
                    break;
                default:
                    throw new \InvalidArgumentException('Object State 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;
    }

    /**
     * @param array $matchCondition
     * @param string $mode
     * @throws \Exception
     * @return array
     */
    public function generateMigration(array $matchCondition, $mode)
    {
        $previousUserId = $this->loginUser(self::ADMIN_USER_ID);
        $objectStateGroupCollection = $this->objectStateGroupMatcher->match($matchCondition);
        $data = array();

        /** @var \eZ\Publish\API\Repository\Values\ObjectState\ObjectStateGroup $objectStateGroup */
        foreach ($objectStateGroupCollection as $objectStateGroup) {

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

            $groupData = array(
                'type' => reset($this->supportedStepTypes),
                'mode' => $mode,
            );

            switch ($mode) {
                case 'create':
                    $groupData = array_merge(
                        $groupData,
                        array(
                            'identifier' => $objectStateGroup->identifier,
                        )
                    );
                    break;
                case 'update':

This code seems to be duplicated across your project.

                    $groupData = array_merge(
                        $groupData,
                        array(
                            'match' => array(
                                ObjectStateGroupMatcher::MATCH_OBJECTSTATEGROUP_IDENTIFIER => $objectStateGroup->identifier
                            ),
                            'identifier' => $objectStateGroup->identifier,
                        )
                    );
                    break;
                case 'delete':

This code seems to be duplicated across your project.

                    $groupData = array_merge(
                        $groupData,
                        array(
                            'match' => array(
                                ObjectStateGroupMatcher::MATCH_OBJECTSTATEGROUP_IDENTIFIER => $objectStateGroup->identifier
                            )
                        )
                    );
                    break;
                default:
                    throw new \Exception("Executor 'object_state_group' doesn't support mode '$mode'");
            }

            if ($mode != 'delete') {
                $names = array();
                $descriptions = array();
                foreach($objectStateGroup->languageCodes as $languageCode) {
                    $names[$languageCode] =  $objectStateGroup->getName($languageCode);
                }
                foreach($objectStateGroup->languageCodes as $languageCode) {
                    $descriptions[$languageCode] =  $objectStateGroup->getDescription($languageCode);
                }
                $groupData = array_merge(
                    $groupData,
                    array(
                        'names' => $names,
                        'descriptions' => $descriptions,
                    )
                );
            }

            $data[] = $groupData;
        }

        $this->loginUser($previousUserId);
        return $data;
    }
}