LanguageManager::generateMigration() - Code Metrics - Inspection of "port enhancements for transaction handling and err..." - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( f754fa...2a1ce4 )

by Gaetano

created 2023-04-19 10:38 UTC

LanguageManager::generateMigration() B

↳ Parent: LanguageManager

Complexity

Conditions	6
Paths	26

Size

Total Lines	63
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	31
CRAP Score	6.008

Importance

Changes

Metric	Value
cc	6
eloc	42
nc	26
nop	3
dl	0
loc	63
ccs	31
cts	33
cp	0.9394
crap	6.008
rs	8.6257
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\Exception\InvalidStepDefinitionException;
use Kaliop\eZMigrationBundle\API\Exception\MigrationBundleException;
use Kaliop\eZMigrationBundle\API\MigrationGeneratorInterface;
use Kaliop\eZMigrationBundle\API\EnumerableMatcherInterface;
use Kaliop\eZMigrationBundle\Core\Matcher\LanguageMatcher;

/**
 * Handles language migrations.
 */
class LanguageManager extends RepositoryExecutor implements MigrationGeneratorInterface, EnumerableMatcherInterface
{
    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 InvalidStepDefinitionException("The 'lang' key is required to create a new language.");
        }

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

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

        return $language;
    }

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

        $this->validateResultsCount($languageCollection, $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);

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

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

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

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

            if (isset($step->dsl['enabled'])) {
                if ($this->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->validateResultsCount($languageCollection, $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 InvalidStepDefinitionException("A match condition is required to $action a language");
        }

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

        $tolerateMisses = isset($step->dsl['match_tolerate_misses']) ? $this->resolveReference($step->dsl['match_tolerate_misses']) : false;

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

    /**
     * @param Language $language
     * @param array $references the definitions of the references to set
     * @throws InvalidStepDefinitionException
     * @return array key: the reference names, values: the reference values
     */
    protected function getReferencesValues($language, array $references, $step)
    {
        $refs = array();

        foreach ($references as $key => $reference) {

            $reference = $this->parseReferenceDefinition($key, $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 InvalidStepDefinitionException('Language Manager does not support setting references for attribute ' . $reference['attribute']);
            }

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

        return $refs;
    }

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

            /** @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 InvalidStepDefinitionException("Executor 'language' doesn't support mode '$mode'");
                }

                $data[] = $languageData;
            }

            $this->loginUser($previousUserId);
        } catch (\Exception $e) {
            $this->loginUser($previousUserId);
            throw $e;
        }

        return $data;
    }

    /**
     * @return string[]
     */
    public function listAllowedConditions()
    {
        return $this->languageMatcher->listAllowedConditions();
    }
}


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

kaliop-uk / ezmigrationbundle

Push — main ( f754fa...2a1ce4 )

LanguageManager::generateMigration() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like