LanguageManager::generateMigration() - Code Metrics - Inspection of "e35419166ce47bbd35b44a7728b2173e66effb01" - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (e35419)

by Gaetano

created 2019-04-10 16:50 UTC

LanguageManager::generateMigration() A

↳ Parent: LanguageManager

Complexity

Conditions	5
Paths	5

Size

Total Lines	57
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
cc	5
eloc	38
nc	5
nop	3
dl	0
loc	57
ccs	0
cts	31
cp	0
crap	30
rs	9.0008
c	0
b	0
f	0

How to fix Long Method

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use eZ\Publish\API\Repository\Values\Content\Language;
use Kaliop\eZMigrationBundle\API\Collection\LanguageCollection;
use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;
use Kaliop\eZMigrationBundle\Core\Matcher\LanguageMatcher;

/**
 * Handles language migrations.
 */
class LanguageManager extends RepositoryExecutor implements MigrationGeneratorInterface
{
    protected $supportedStepTypes = array('language');
    protected $supportedActions = array('create', 'load', 'update', 'delete');

    /** @var LanguageMatcher $languageMatcher */
    protected $languageMatcher;

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

    /**
     * Handles the language create migration action
     *
     * @todo allow creating disabkled languages
     */
    protected function create($step)
    {
        $languageService = $this->repository->getContentLanguageService();

        if (!isset($step->dsl['lang'])) {
            throw new \Exception("The 'lang' key is required to create a new language.");
        }

        $languageCreateStruct = $languageService->newLanguageCreateStruct();
        $languageCreateStruct->languageCode = $this->referenceResolver->resolveReference($step->dsl['lang']);
        if (isset($step->dsl['name'])) {
            $languageCreateStruct->name = $this->referenceResolver->resolveReference($step->dsl['name']);
        }
        if (isset($step->dsl['enabled'])) {
            $languageCreateStruct->enabled = (bool)$this->referenceResolver->resolveReference($step->dsl['enabled']);
        }
        $language = $languageService->createLanguage($languageCreateStruct);

        $this->setReferences($language, $step);

        return $language;
    }

    protected function load($step)
    {
        $languageCollection = $this->matchLanguages('load', $step);

        $this->setReferences($languageCollection, $step);

        return $languageCollection;
    }

    /**
     * Handles the language update migration action
     */
    protected function update($step)
    {
        if (isset($step->dsl['lang'])) {
            // BC
            $step->dsl['match'] = array('language_code' => $step->dsl['lang']);
        }

        $languageCollection = $this->matchLanguages('delete', $step);

        if (count($languageCollection) > 1 && array_key_exists('references', $step->dsl)) {
            throw new \Exception("Can not execute Language update because multiple languages match, and a references section is specified in the dsl. References can be set when only 1 language matches");
        }

        $languageService = $this->repository->getContentLanguageService();

        foreach ($languageCollection as $key => $language) {

            if (isset($step->dsl['name'])) {
                $languageService->updateLanguageName($language, $this->referenceResolver->resolveReference($step->dsl['name']));
            }

            if (isset($step->dsl['enabled'])) {
                if ($this->referenceResolver->resolveReference($step->dsl['enabled'])) {
                    $languageService->enableLanguage($language);
                } else {
                    $languageService->disableLanguage($language);
                };
            }

            $languageCollection[$key] = $languageService->loadLanguageById($key);
        }

        $this->setReferences($languageCollection, $step);

        return $languageCollection;
    }

    /**
     * Handles the language delete migration action
     */
    protected function delete($step)
    {
        if (isset($step->dsl['lang'])) {
            // BC
            $step->dsl['match'] = array('language_code' => $step->dsl['lang']);
        }
        $languageCollection = $this->matchLanguages('delete', $step);

        $this->setReferences($languageCollection, $step);

        $languageService = $this->repository->getContentLanguageService();

        foreach ($languageCollection as $language) {
            $languageService->deleteLanguage($language);
        }

        return $languageCollection;
    }

    /**
     * @param string $action
     * @return LanguageCollection
     * @throws \Exception
     */
    protected function matchLanguages($action, $step)
    {
        if (!isset($step->dsl['match'])) {
            throw new \Exception("A match condition is required to $action a language");
        }

        // convert the references passed in the match
        $match = $this->resolveReferencesRecursively($step->dsl['match']);

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

    /**
     * @param Language $language
     * @param array $references the definitions of the references to set
     * @throws \InvalidArgumentException When trying to assign a reference to an unsupported attribute
     * @return array key: the reference names, values: the reference values
     */
    protected function getReferencesValues($language, array $references, $step)
    {
        $refs = array();

        foreach ($references as $reference) {

            switch ($reference['attribute']) {
                case 'language_id':
                case 'id':
                    $value = $language->id;
                    break;
                case 'enabled':
                    $value = $language->enabled;
                    break;
                case 'language_code':
                    $value = $language->languageCode;
                    break;
                case 'language_name':
                case 'name':
                    $value = $language->name;
                    break;
                default:
                    throw new \InvalidArgumentException('Language Manager does not support setting references for attribute ' . $reference['attribute']);
            }

            $refs[$reference['identifier']] = $value;
        }

        return $refs;
    }

    /**
     * @param array $matchCondition
     * @param string $mode
     * @param array $context
     * @throws \Exception
     * @return array
     */
    public function generateMigration(array $matchCondition, $mode, array $context = array())
    {
        $previousUserId = $this->loginUser($this->getAdminUserIdentifierFromContext($context));
        $languageCollection = $this->languageMatcher->match($matchCondition);
        $data = array();

        /** @var \eZ\Publish\API\Repository\Values\Content\Language $language */
        foreach ($languageCollection as $language) {

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

            switch ($mode) {
                case 'create':
                    $languageData = array_merge(
                        $languageData,
                        array(
                            'lang' => $language->languageCode,
                            'name' => $language->name,
                            'enabled' => $language->enabled
                        )
                    );
                    break;
                case 'update':
                    $languageData = array_merge(
                        $languageData,
                        array(
                            'match' => array(
                                LanguageMatcher::MATCH_LANGUAGE_ID => $language->id
                            ),
                            'lang' => $language->languageCode,
                            'name' => $language->name,
                            'enabled' => $language->enabled
                        )
                    );
                    break;
                case 'delete':
                    $languageData = array_merge(
                        $languageData,
                        array(
                            'match' => array(
                                LanguageMatcher::MATCH_LANGUAGE_ID => $language->id
                            )
                        )
                    );
                    break;
                default:
                    throw new \Exception("Executor 'language' doesn't support mode '$mode'");
            }

            $data[] = $languageData;
        }

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


1		<?php
2
3		namespace Kaliop\eZMigrationBundle\Core\Executor;
4
5		use eZ\Publish\API\Repository\Values\Content\Language;
6		use Kaliop\eZMigrationBundle\API\Collection\LanguageCollection;
7		use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;
8		use Kaliop\eZMigrationBundle\Core\Matcher\LanguageMatcher;
9
10		/**
11		* Handles language migrations.
12		*/
13		class LanguageManager extends RepositoryExecutor implements MigrationGeneratorInterface
14		{
15		protected $supportedStepTypes = array('language');
16		protected $supportedActions = array('create', 'load', 'update', 'delete');
17
18		/** @var LanguageMatcher $languageMatcher */
19		protected $languageMatcher;
20
21		/**
22		* @param LanguageMatcher $languageMatcher
23		*/
24	80	public function __construct(LanguageMatcher $languageMatcher)
25		{
26	80	$this->languageMatcher = $languageMatcher;
27	80	}
28
29		/**
30		* Handles the language create migration action
31		*
32		* @todo allow creating disabkled languages
33		*/
34	5	protected function create($step)
35		{
36	5	$languageService = $this->repository->getContentLanguageService();
37
38	5	if (!isset($step->dsl['lang'])) {
39		throw new \Exception("The 'lang' key is required to create a new language.");
40		}
41
42	5	$languageCreateStruct = $languageService->newLanguageCreateStruct();
43	5	$languageCreateStruct->languageCode = $this->referenceResolver->resolveReference($step->dsl['lang']);
44	5	if (isset($step->dsl['name'])) {
45	5	$languageCreateStruct->name = $this->referenceResolver->resolveReference($step->dsl['name']);
46		}
47	5	if (isset($step->dsl['enabled'])) {
48		$languageCreateStruct->enabled = (bool)$this->referenceResolver->resolveReference($step->dsl['enabled']);
49		}
50	5	$language = $languageService->createLanguage($languageCreateStruct);
51
52	5	$this->setReferences($language, $step);
53
54	5	return $language;
55		}
56
57	1	protected function load($step)
58		{
59	1	$languageCollection = $this->matchLanguages('load', $step);
60
61	1	$this->setReferences($languageCollection, $step);
62
63	1	return $languageCollection;
64		}
65
66		/**
67		* Handles the language update migration action
68		*/
69	1	protected function update($step)
70		{
71	1	if (isset($step->dsl['lang'])) {
72		// BC
73		$step->dsl['match'] = array('language_code' => $step->dsl['lang']);
74		}
75
76	1	$languageCollection = $this->matchLanguages('delete', $step);
77
78	1	if (count($languageCollection) > 1 && array_key_exists('references', $step->dsl)) {
79		throw new \Exception("Can not execute Language update because multiple languages match, and a references section is specified in the dsl. References can be set when only 1 language matches");
80		}
81
82	1	$languageService = $this->repository->getContentLanguageService();
83
84	1	foreach ($languageCollection as $key => $language) {
85
86	1	if (isset($step->dsl['name'])) {
87	1	$languageService->updateLanguageName($language, $this->referenceResolver->resolveReference($step->dsl['name']));
88		}
89
90	1	if (isset($step->dsl['enabled'])) {
91	1	if ($this->referenceResolver->resolveReference($step->dsl['enabled'])) {
92		$languageService->enableLanguage($language);
93		} else {
94	1	$languageService->disableLanguage($language);
95		};
96		}
97
98	1	$languageCollection[$key] = $languageService->loadLanguageById($key);
99		}
100
101	1	$this->setReferences($languageCollection, $step);
102
103	1	return $languageCollection;
104		}
105
106		/**
107		* Handles the language delete migration action
108		*/
109	1	protected function delete($step)
110		{
111	1	if (isset($step->dsl['lang'])) {
112		// BC
113		$step->dsl['match'] = array('language_code' => $step->dsl['lang']);
114		}
115	1	$languageCollection = $this->matchLanguages('delete', $step);
116
117	1	$this->setReferences($languageCollection, $step);
118
119	1	$languageService = $this->repository->getContentLanguageService();
120
121	1	foreach ($languageCollection as $language) {
122	1	$languageService->deleteLanguage($language);
123		}
124
125	1	return $languageCollection;
126		}
127
128		/**
129		* @param string $action
130		* @return LanguageCollection
131		* @throws \Exception
132		*/
133	1	protected function matchLanguages($action, $step)
134		{
135	1	if (!isset($step->dsl['match'])) {
136		throw new \Exception("A match condition is required to $action a language");
137		}
138
139		// convert the references passed in the match
140	1	$match = $this->resolveReferencesRecursively($step->dsl['match']);
141
142	1	return $this->languageMatcher->match($match);
143		}
144
145		/**
146		* @param Language $language
147		* @param array $references the definitions of the references to set
148		* @throws \InvalidArgumentException When trying to assign a reference to an unsupported attribute
149		* @return array key: the reference names, values: the reference values
150		*/
151	1	protected function getReferencesValues($language, array $references, $step)
152		{
153	1	$refs = array();
154
155	1	foreach ($references as $reference) {
156
157	1	switch ($reference['attribute']) {
158	1	case 'language_id':
159	1	case 'id':
160	1	$value = $language->id;
161	1	break;
162		case 'enabled':
163		$value = $language->enabled;
164		break;
165		case 'language_code':
166		$value = $language->languageCode;
167		break;
168		case 'language_name':
169		case 'name':
170		$value = $language->name;
171		break;
172		default:
173		throw new \InvalidArgumentException('Language Manager does not support setting references for attribute ' . $reference['attribute']);
174		}
175
176	1	$refs[$reference['identifier']] = $value;
177		}
178
179	1	return $refs;
180		}
181
182		/**
183		* @param array $matchCondition
184		* @param string $mode
185		* @param array $context
186		* @throws \Exception
187		* @return array
188		*/
189		public function generateMigration(array $matchCondition, $mode, array $context = array())
190		{
191		$previousUserId = $this->loginUser($this->getAdminUserIdentifierFromContext($context));
192		$languageCollection = $this->languageMatcher->match($matchCondition);
193		$data = array();
194
195		/** @var \eZ\Publish\API\Repository\Values\Content\Language $language */
196		foreach ($languageCollection as $language) {
197
198		$languageData = array(
199		'type' => reset($this->supportedStepTypes),
200		'mode' => $mode,
201		);
202
203		switch ($mode) {
204		case 'create':
205		$languageData = array_merge(
206		$languageData,
207		array(
208		'lang' => $language->languageCode,
209		'name' => $language->name,
210		'enabled' => $language->enabled
211		)
212		);
213		break;
214		case 'update':
215		$languageData = array_merge(
216		$languageData,
217		array(
218		'match' => array(
219		LanguageMatcher::MATCH_LANGUAGE_ID => $language->id
220		),
221		'lang' => $language->languageCode,
222		'name' => $language->name,
223		'enabled' => $language->enabled
224		)
225		);
226		break;
227		case 'delete':
228		$languageData = array_merge(
229		$languageData,
230		array(
231		'match' => array(
232		LanguageMatcher::MATCH_LANGUAGE_ID => $language->id
233		)
234		)
235		);
236		break;
237		default:
238		throw new \Exception("Executor 'language' doesn't support mode '$mode'");
239		}
240
241		$data[] = $languageData;
242		}
243
244		$this->loginUser($previousUserId);
245		return $data;
246		}
247		}
248

kaliop-uk / ezmigrationbundle

Branch — master (e35419)

LanguageManager::generateMigration() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like