RepositoryExecutor::insureEntityCountCompatibility() - Code Metrics - Inspection of "more fixes to refactoring" - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ecad36...91ef09 )

by Gaetano

created 2018-05-13 13:51 UTC

insureEntityCountCompatibility() B

↳ Parent: RepositoryExecutor

Complexity

Conditions	7
Paths	7

Size

Total Lines	15
Code Lines	8

Duplication

Lines	6
Ratio	40 %

Code Coverage

Tests	0
CRAP Score	56

Importance

Changes

Metric	Value
dl	6
loc	15
ccs	0
cts	0
cp	0
rs	8.2222
c	0
b	0
f	0
cc	7
eloc	8
nc	7
nop	2
crap	56

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use eZ\Publish\API\Repository\Repository;
use eZ\Publish\Core\MVC\ConfigResolverInterface;
use Kaliop\eZMigrationBundle\API\Collection\AbstractCollection;
use Kaliop\eZMigrationBundle\API\ReferenceResolverBagInterface;
use Kaliop\eZMigrationBundle\API\Value\MigrationStep;
use Kaliop\eZMigrationBundle\Core\RepositoryUserSetterTrait;

/**
 * The core manager class that all migration action managers inherit from.
 */
abstract class RepositoryExecutor extends AbstractExecutor
{
    use RepositoryUserSetterTrait;
    use IgnorableStepExecutorTrait;

    /**
     * Constant defining the default language code (used if not specified by the migration or on the command line)
     */
    const DEFAULT_LANGUAGE_CODE = 'eng-GB';

    /**
     * The default Admin user Id, used when no Admin user is specified
     */
    const ADMIN_USER_ID = 14;

    /** Used if not specified by the migration */
    const USER_CONTENT_TYPE = 'user';

    /**
     * @var array $dsl The parsed DSL instruction array
     */
    //protected $dsl;

    /** @var array $context The context (configuration) for the execution of the current step */
    //protected $context;

    /**
     * The eZ Publish 5 API repository.
     *
     * @var \eZ\Publish\API\Repository\Repository
     */
    protected $repository;

    protected $configResolver;

    /** @var ReferenceResolverBagInterface $referenceResolver */
    protected $referenceResolver;

    // to redefine in subclasses if they don't support all methods, or if they support more...
    protected $supportedActions = array(
        'create', 'update', 'delete'
    );

    public function setRepository(Repository $repository)
    {
        $this->repository = $repository;
    }

    public function setConfigResolver(ConfigResolverInterface $configResolver)
    {
        $this->configResolver = $configResolver;
    }

    public function setReferenceResolver(ReferenceResolverBagInterface $referenceResolver)
    {
        $this->referenceResolver = $referenceResolver;
    }

    public function execute(MigrationStep $step)
    {
        // base checks
        parent::execute($step);

        if (!isset($step->dsl['mode'])) {
            throw new \Exception("Invalid step definition: missing 'mode'");
        }

        // q: should we convert snake_case to camelCase ?
        $action = $step->dsl['mode'];

        if (!in_array($action, $this->supportedActions)) {
            throw new \Exception("Invalid step definition: value '$action' is not allowed for 'mode'");
        }

        if (method_exists($this, $action)) {

            $this->skipStepIfNeeded($step);

            $previousUserId = $this->loginUser($this->getAdminUserIdentifierFromContext($step->context));

            try {
                $output = $this->$action($step);
            } catch (\Exception $e) {
                $this->loginUser($previousUserId);
                throw $e;
            }

            // reset the environment as much as possible as we had found it before the migration
            $this->loginUser($previousUserId);

            return $output;
        } else {
            throw new \Exception("Invalid step definition: value '$action' is not a method of " . get_class($this));
        }
    }

    /**
     * Method that each executor (subclass) has to implement.
     *
     * It is used to get values for references based on the DSL instructions executed in the current step, for later steps to reuse.
     *
     * @throws \InvalidArgumentException when trying to set a reference to an unsupported attribute.
     * @param $object a sinle element to extract reference values from
     * @param array $referencesDefinitionsthe definitions of the references to extract
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return array key: the reference name (taken from $referencesDefinitions[n]['identifier'], value: the ref. value
     */
    abstract protected function getReferencesValues($object, array $referencesDefinitions);

    /**
     * @param MigrationStep $step
     * @return string
     */
    protected function getLanguageCode($step)
    {
        return isset($step->dsl['lang']) ? $step->dsl['lang'] : $this->getLanguageCodeFromContext($step->context);
    }

    /**
     * @param array|null $context
     * @return string
     */
    protected function getLanguageCodeFromContext($context)
    {
        if (is_array($context) && isset($context['defaultLanguageCode'])) {
            return $context['defaultLanguageCode'];
        }

        if ($this->configResolver) {
            $locales = $this->configResolver->getParameter('languages');
            return reset($locales);
        }

        return self::DEFAULT_LANGUAGE_CODE;
    }

    /**
     * @param MigrationStep $step
     * @return string
     */
    protected function getUserContentType($step)
    {
        return isset($step->dsl['user_content_type']) ? $step->dsl['user_content_type'] : $this->getUserContentTypeFromContext($step->context);
    }

    /**
     * @param array $context
     * @return string
     */
    protected function getUserContentTypeFromContext($context)
    {
        return isset($context['userContentType']) ? $context['userContentType'] : self::USER_CONTENT_TYPE;
    }

    /**
     * @param array $context we have to return FALSE if that is set as adminUserLogin, whereas if NULL is set, we return the default admin
     * @return int|string|false
     */
    protected function getAdminUserIdentifierFromContext($context)
    {
        if (isset($context['adminUserLogin'])) {
            return $context['adminUserLogin'];
        }

        return self::ADMIN_USER_ID;
    }

    /**
     * Sets references to certain attributes of the items returned by steps.
     *
     * @param \Object|AbstractCollection $item
     * @param MigrationStep $step
     * @throws \InvalidArgumentException When trying to set a reference to an unsupported attribute
     * @return boolean
     */
    protected function setReferences($item, $step)
    {
        if (!array_key_exists('references', $step->dsl)) {
            return false;
        }

        $referencesDefs = $this->setReferencesCommon($item, $step->dsl['references']);

        $this->insureEntityCountCompatibility($item, $referencesDefs);

        $multivalued = $this->areReferencesMultivalued($referencesDefs);

        if ($item instanceof AbstractCollection) {
            $items = $item;
        } else {
            $items = array($item);
        }

        if (isset($referencesDefs['multivalued'])) {
            unset($referencesDefs['multivalued']);
        }

        $referencesValues = array();
        foreach ($items as $item) {
            $itemReferencesValues = $this->getReferencesValues($item, $referencesDefs);
            if (!$multivalued) {
                $referencesValues = $itemReferencesValues;
            } else {
                foreach ($itemReferencesValues as $refName => $refValue) {
                    if (!isset($referencesValues[$refName])) {
                        $referencesValues[$refName] = array($refValue);
                    } else {
                        $referencesValues[$refName][] = $refValue;
                    }
                }
            }
        }

        foreach($referencesDefs as $reference) {

            $overwrite = false;
            if (isset($reference['overwrite'])) {
                $overwrite = $reference['overwrite'];
            }
            $this->referenceResolver->addReference($reference['identifier'], $referencesValues[$reference['identifier']], $overwrite);
        }


        return true;
    }

    /**
     * @param mixed $entity
     * @param array $referencesDefinition
     * @return array the same as $referencesDefinition, with the references already treated having been removed
     */
    protected function setReferencesCommon($entity, $referencesDefinition)
    {
        // allow setting *some* refs even when we have 0 or N matches
        foreach ($referencesDefinition as $key => $reference) {
            switch($reference['attribute']) {

                case 'count':
                    $value = count($entity);
                    $overwrite = false;
                    if (isset($reference['overwrite'])) {
                        $overwrite = $reference['overwrite'];
                    }
                    $this->referenceResolver->addReference($reference['identifier'], $value, $overwrite);
                    unset($referencesDefinition[$key]);
                    break;

                default:
                    // do nothing
            }
        }

        return $referencesDefinition;
    }

    /**
     * Verifies compatibility between the definition of the refences to be set and the data set to extarct them from,
     * and returns a single entity
     *
     * @param AbstractCollection|mixed $entity
     * @param array $referencesDefinition
     * @return AbstractCollection|mixed
     */
    protected function insureSingleEntity($entity, $referencesDefinition)
    {
        $this->insureEntityCountCompatibility($entity, $referencesDefinition);

        if ($entity instanceof AbstractCollection) {
            return reset($entity);
        }

        return $entity;
    }

    /**
     * Verifies compatibility between the definition of the refences to be set and the data set to extract them from.
     * Nb: for multivalued refs, we assume that the users always expect at least one value
     * @param AbstractCollection|mixed $entity
     * @param array $referencesDefinition
     * @return void throws when incompatibiliy is found
     * @todo should we allow to be passed in plain arrays as well ?
     */
    protected function insureEntityCountCompatibility($entity, $referencesDefinition)
    {
        if ($entity instanceof AbstractCollection) {

            $minOneRef = count($referencesDefinition) > 0;
            $maxOneRef = count($referencesDefinition) > 0 && ! $this->areReferencesMultivalued($referencesDefinition);

            if ($maxOneRef && count($entity) > 1) {

                throw new \InvalidArgumentException($this->getSelfName() . ' does not support setting references for multiple ' . $this->getCollectionName($entity) . 's');
            }
            if ($minOneRef && count($entity) == 0) {

                throw new \InvalidArgumentException($this->getSelfName() . ' does not support setting references for no ' . $this->getCollectionName($entity) . 's');
            }
        }
    }

    protected function areReferencesMultivalued($referencesDefinition)
    {
        return isset($referencesDefinition['multivalued']) && $referencesDefinition['multivalued'] == 'enabled';
    }

    protected function getSelfName()
    {
        $className = get_class($this);
        $array = explode('\\', $className);
        $className = end($array);
        // CamelCase to Camel Case using negative look-behind in regexp
        return preg_replace('/(?<!^)[A-Z]/', ' $0', $className);
    }

    protected function getCollectionName($collection)
    {
        $className = get_class($collection);
        $array = explode('\\', $className);
        $className = str_replace('Collection', '', end($array));
        // CamelCase to snake case using negative look-behind in regexp
        return strtolower(preg_replace('/(?<!^)[A-Z]/', ' $0', $className));
    }

    /**
     * Courtesy code to avoid reimplementing it in every subclass
     * @todo will be moved into the reference resolver classes
     */
    protected function resolveReferencesRecursively($match)

    {
        if (is_array($match)) {
            foreach ($match as $condition => $values) {
                $match[$condition] = $this->resolveReferencesRecursively($values);
            }
            return $match;
        } else {
            return $this->referenceResolver->resolveReference($match);
        }
    }
}


1		<?php
2
3		namespace Kaliop\eZMigrationBundle\Core\Executor;
4
5		use eZ\Publish\API\Repository\Repository;
6		use eZ\Publish\Core\MVC\ConfigResolverInterface;
7		use Kaliop\eZMigrationBundle\API\Collection\AbstractCollection;
8		use Kaliop\eZMigrationBundle\API\ReferenceResolverBagInterface;
9		use Kaliop\eZMigrationBundle\API\Value\MigrationStep;
10		use Kaliop\eZMigrationBundle\Core\RepositoryUserSetterTrait;
11
12		/**
13		* The core manager class that all migration action managers inherit from.
14		*/
15		abstract class RepositoryExecutor extends AbstractExecutor
16		{
17		use RepositoryUserSetterTrait;
18		use IgnorableStepExecutorTrait;
19
20		/**
21		* Constant defining the default language code (used if not specified by the migration or on the command line)
22		*/
23		const DEFAULT_LANGUAGE_CODE = 'eng-GB';
24
25		/**
26		* The default Admin user Id, used when no Admin user is specified
27		*/
28		const ADMIN_USER_ID = 14;
29
30		/** Used if not specified by the migration */
31		const USER_CONTENT_TYPE = 'user';
32
33		/**
34		* @var array $dsl The parsed DSL instruction array
35		*/
36		//protected $dsl;
37
38		/** @var array $context The context (configuration) for the execution of the current step */
39		//protected $context;
40
41		/**
42		* The eZ Publish 5 API repository.
43		*
44		* @var \eZ\Publish\API\Repository\Repository
45		*/
46		protected $repository;
47
48		protected $configResolver;
49
50		/** @var ReferenceResolverBagInterface $referenceResolver */
51		protected $referenceResolver;
52
53		// to redefine in subclasses if they don't support all methods, or if they support more...
54		protected $supportedActions = array(
55		'create', 'update', 'delete'
56		);
57
58		public function setRepository(Repository $repository)
59		{
60		$this->repository = $repository;
61		}
62
63		public function setConfigResolver(ConfigResolverInterface $configResolver)
64		{
65		$this->configResolver = $configResolver;
66		}
67
68		public function setReferenceResolver(ReferenceResolverBagInterface $referenceResolver)
69		{
70		$this->referenceResolver = $referenceResolver;
71		}
72
73		public function execute(MigrationStep $step)
74		{
75		// base checks
76		parent::execute($step);
77
78		if (!isset($step->dsl['mode'])) {
79		throw new \Exception("Invalid step definition: missing 'mode'");
80		}
81
82		// q: should we convert snake_case to camelCase ?
83		$action = $step->dsl['mode'];
84
85		if (!in_array($action, $this->supportedActions)) {
86		throw new \Exception("Invalid step definition: value '$action' is not allowed for 'mode'");
87		}
88
89		if (method_exists($this, $action)) {
90
91		$this->skipStepIfNeeded($step);
92
93		$previousUserId = $this->loginUser($this->getAdminUserIdentifierFromContext($step->context));
94
95		try {
96		$output = $this->$action($step);
97		} catch (\Exception $e) {
98		$this->loginUser($previousUserId);
99		throw $e;
100		}
101
102		// reset the environment as much as possible as we had found it before the migration
103		$this->loginUser($previousUserId);
104
105		return $output;
106		} else {
107		throw new \Exception("Invalid step definition: value '$action' is not a method of " . get_class($this));
108		}
109		}
110
111		/**
112		* Method that each executor (subclass) has to implement.
113		*
114		* It is used to get values for references based on the DSL instructions executed in the current step, for later steps to reuse.
115		*
116		* @throws \InvalidArgumentException when trying to set a reference to an unsupported attribute.
117		* @param $object a sinle element to extract reference values from
118		* @param array $referencesDefinitionsthe definitions of the references to extract
		0 ignored issues – show Documentation introduced 2018-05-12 16:46 UTC by Report Bug Copy Issue Report There is no parameter named `$referencesDefinitionsthe`. Did you maybe mean `$referencesDefinitions`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
119		* @return array key: the reference name (taken from $referencesDefinitions[n]['identifier'], value: the ref. value
120		*/
121		abstract protected function getReferencesValues($object, array $referencesDefinitions);
122
123		/**
124		* @param MigrationStep $step
125		* @return string
126		*/
127		protected function getLanguageCode($step)
128		{
129		return isset($step->dsl['lang']) ? $step->dsl['lang'] : $this->getLanguageCodeFromContext($step->context);
130		}
131
132		/**
133		* @param array\|null $context
134		* @return string
135		*/
136		protected function getLanguageCodeFromContext($context)
137		{
138		if (is_array($context) && isset($context['defaultLanguageCode'])) {
139		return $context['defaultLanguageCode'];
140		}
141
142		if ($this->configResolver) {
143		$locales = $this->configResolver->getParameter('languages');
144		return reset($locales);
145		}
146
147		return self::DEFAULT_LANGUAGE_CODE;
148		}
149
150		/**
151		* @param MigrationStep $step
152		* @return string
153		*/
154		protected function getUserContentType($step)
155		{
156		return isset($step->dsl['user_content_type']) ? $step->dsl['user_content_type'] : $this->getUserContentTypeFromContext($step->context);
157		}
158
159		/**
160		* @param array $context
161		* @return string
162		*/
163		protected function getUserContentTypeFromContext($context)
164		{
165		return isset($context['userContentType']) ? $context['userContentType'] : self::USER_CONTENT_TYPE;
166		}
167
168		/**
169		* @param array $context we have to return FALSE if that is set as adminUserLogin, whereas if NULL is set, we return the default admin
170		* @return int\|string\|false
171		*/
172		protected function getAdminUserIdentifierFromContext($context)
173		{
174		if (isset($context['adminUserLogin'])) {
175		return $context['adminUserLogin'];
176		}
177
178		return self::ADMIN_USER_ID;
179		}
180
181		/**
182		* Sets references to certain attributes of the items returned by steps.
183		*
184		* @param \Object\|AbstractCollection $item
185		* @param MigrationStep $step
186		* @throws \InvalidArgumentException When trying to set a reference to an unsupported attribute
187		* @return boolean
188		*/
189		protected function setReferences($item, $step)
190		{
191		if (!array_key_exists('references', $step->dsl)) {
192		return false;
193		}
194
195		$referencesDefs = $this->setReferencesCommon($item, $step->dsl['references']);
196
197		$this->insureEntityCountCompatibility($item, $referencesDefs);
198
199		$multivalued = $this->areReferencesMultivalued($referencesDefs);
200
201		if ($item instanceof AbstractCollection) {
202		$items = $item;
203		} else {
204		$items = array($item);
205		}
206
207		if (isset($referencesDefs['multivalued'])) {
208		unset($referencesDefs['multivalued']);
209		}
210
211		$referencesValues = array();
212		foreach ($items as $item) {
213		$itemReferencesValues = $this->getReferencesValues($item, $referencesDefs);
214		if (!$multivalued) {
215		$referencesValues = $itemReferencesValues;
216		} else {
217		foreach ($itemReferencesValues as $refName => $refValue) {
218		if (!isset($referencesValues[$refName])) {
219		$referencesValues[$refName] = array($refValue);
220		} else {
221		$referencesValues[$refName][] = $refValue;
222		}
223		}
224		}
225		}
226
227	View Code Duplication	foreach($referencesDefs as $reference) {
		0 ignored issues – show Duplication introduced 2018-05-12 16:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
228		$overwrite = false;
229		if (isset($reference['overwrite'])) {
230		$overwrite = $reference['overwrite'];
231		}
232		$this->referenceResolver->addReference($reference['identifier'], $referencesValues[$reference['identifier']], $overwrite);
233		}
234
235
236		return true;
237		}
238
239		/**
240		* @param mixed $entity
241		* @param array $referencesDefinition
242		* @return array the same as $referencesDefinition, with the references already treated having been removed
243		*/
244		protected function setReferencesCommon($entity, $referencesDefinition)
245		{
246		// allow setting some refs even when we have 0 or N matches
247		foreach ($referencesDefinition as $key => $reference) {
248		switch($reference['attribute']) {
249
250		case 'count':
251		$value = count($entity);
252		$overwrite = false;
253		if (isset($reference['overwrite'])) {
254		$overwrite = $reference['overwrite'];
255		}
256		$this->referenceResolver->addReference($reference['identifier'], $value, $overwrite);
257		unset($referencesDefinition[$key]);
258		break;
259
260		default:
261		// do nothing
262		}
263		}
264
265		return $referencesDefinition;
266		}
267
268		/**
269		* Verifies compatibility between the definition of the refences to be set and the data set to extarct them from,
270		* and returns a single entity
271		*
272		* @param AbstractCollection\|mixed $entity
273		* @param array $referencesDefinition
274		* @return AbstractCollection\|mixed
275		*/
276		protected function insureSingleEntity($entity, $referencesDefinition)
277		{
278		$this->insureEntityCountCompatibility($entity, $referencesDefinition);
279
280		if ($entity instanceof AbstractCollection) {
281		return reset($entity);
282		}
283
284		return $entity;
285		}
286
287		/**
288		* Verifies compatibility between the definition of the refences to be set and the data set to extract them from.
289		* Nb: for multivalued refs, we assume that the users always expect at least one value
290		* @param AbstractCollection\|mixed $entity
291		* @param array $referencesDefinition
292		* @return void throws when incompatibiliy is found
293		* @todo should we allow to be passed in plain arrays as well ?
294		*/
295		protected function insureEntityCountCompatibility($entity, $referencesDefinition)
296		{
297		if ($entity instanceof AbstractCollection) {
298
299		$minOneRef = count($referencesDefinition) > 0;
300		$maxOneRef = count($referencesDefinition) > 0 && ! $this->areReferencesMultivalued($referencesDefinition);
301
302	View Code Duplication	if ($maxOneRef && count($entity) > 1) {
		0 ignored issues – show Duplication introduced 2018-05-12 16:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
303		throw new \InvalidArgumentException($this->getSelfName() . ' does not support setting references for multiple ' . $this->getCollectionName($entity) . 's');
304		}
305	View Code Duplication	if ($minOneRef && count($entity) == 0) {
		0 ignored issues – show Duplication introduced 2018-05-12 16:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
306		throw new \InvalidArgumentException($this->getSelfName() . ' does not support setting references for no ' . $this->getCollectionName($entity) . 's');
307		}
308		}
309		}
310
311		protected function areReferencesMultivalued($referencesDefinition)
312		{
313		return isset($referencesDefinition['multivalued']) && $referencesDefinition['multivalued'] == 'enabled';
314		}
315
316		protected function getSelfName()
317		{
318		$className = get_class($this);
319		$array = explode('\\', $className);
320		$className = end($array);
321		// CamelCase to Camel Case using negative look-behind in regexp
322		return preg_replace('/(?<!^)[A-Z]/', ' $0', $className);
323		}
324
325		protected function getCollectionName($collection)
326		{
327		$className = get_class($collection);
328		$array = explode('\\', $className);
329		$className = str_replace('Collection', '', end($array));
330		// CamelCase to snake case using negative look-behind in regexp
331		return strtolower(preg_replace('/(?<!^)[A-Z]/', ' $0', $className));
332		}
333
334		/**
335		* Courtesy code to avoid reimplementing it in every subclass
336		* @todo will be moved into the reference resolver classes
337		*/
338	View Code Duplication	protected function resolveReferencesRecursively($match)
		0 ignored issues – show Duplication introduced 2017-08-29 17:16 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
339		{
340		if (is_array($match)) {
341		foreach ($match as $condition => $values) {
342		$match[$condition] = $this->resolveReferencesRecursively($values);
343		}
344		return $match;
345		} else {
346		return $this->referenceResolver->resolveReference($match);
347		}
348		}
349		}
350

kaliop-uk / ezmigrationbundle

Push — master ( ecad36...91ef09 )

insureEntityCountCompatibility() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like