LanguageService - Code Metrics - Inspection of "EZP-30006: As a Developer I possibility to load se..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f2dfe9...84d91c )

by André

created 2019-02-19 07:33 UTC

LanguageService A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	377
Duplicated Lines	21.75 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes

Metric	Value
dl	82
loc	377
rs	9.2
c	0
b	0
f	0
wmc	40
lcom	2
cbo	9

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
B	createLanguage()	6	45	10
A	updateLanguageName()	0	32	5
A	enableLanguage()	28	28	3
A	disableLanguage()	28	28	3
A	loadLanguage()	0	10	3
A	loadLanguages()	0	11	2
A	loadLanguageById()	0	6	1
A	loadLanguageListByCode()	0	11	2
A	loadLanguageListById()	0	11	2
A	deleteLanguage()	20	20	4
A	getDefaultLanguageCode()	0	4	1
A	getPrioritizedLanguageCodeList()	0	4	1
A	newLanguageCreateStruct()	0	4	1
A	buildDomainObject()	0	11	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like LanguageService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use LanguageService, and based on these observations, apply Extract Interface, too.

<?php

/**
 * File containing the eZ\Publish\Core\Repository\LanguageService class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Repository;

use eZ\Publish\API\Repository\LanguageService as LanguageServiceInterface;
use eZ\Publish\SPI\Persistence\Content\Language\Handler;
use eZ\Publish\API\Repository\Repository as RepositoryInterface;
use eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct;
use eZ\Publish\SPI\Persistence\Content\Language as SPILanguage;
use eZ\Publish\SPI\Persistence\Content\Language\CreateStruct;
use eZ\Publish\API\Repository\Values\Content\Language;
use eZ\Publish\API\Repository\Exceptions\NotFoundException as APINotFoundException;
use eZ\Publish\Core\Base\Exceptions\InvalidArgumentValue;
use eZ\Publish\Core\Base\Exceptions\InvalidArgumentException;
use eZ\Publish\Core\Base\Exceptions\UnauthorizedException;
use LogicException;
use Exception;

/**
 * Language service, used for language operations.
 */
class LanguageService implements LanguageServiceInterface
{
    /**
     * @var \eZ\Publish\API\Repository\Repository
     */
    protected $repository;

    /**
     * @var \eZ\Publish\SPI\Persistence\Content\Language\Handler
     */
    protected $languageHandler;

    /**
     * @var array
     */
    protected $settings;

    /**
     * Setups service with reference to repository object that created it & corresponding handler.
     *
     * @param \eZ\Publish\API\Repository\Repository $repository
     * @param \eZ\Publish\SPI\Persistence\Content\Language\Handler $languageHandler
     * @param array $settings
     */
    public function __construct(RepositoryInterface $repository, Handler $languageHandler, array $settings = array())
    {
        $this->repository = $repository;
        $this->languageHandler = $languageHandler;
        // Union makes sure default settings are ignored if provided in argument
        $this->settings = $settings + array(
            'languages' => array('eng-GB'),
        );
    }

    /**
     * Creates the a new Language in the content repository.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the languageCode already exists
     *
     * @param \eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct $languageCreateStruct
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function createLanguage(LanguageCreateStruct $languageCreateStruct)
    {
        if (!is_string($languageCreateStruct->name) || empty($languageCreateStruct->name)) {

            throw new InvalidArgumentValue('name', $languageCreateStruct->name, 'LanguageCreateStruct');
        }

        if (!is_string($languageCreateStruct->languageCode) || empty($languageCreateStruct->languageCode)) {

            throw new InvalidArgumentValue('languageCode', $languageCreateStruct->languageCode, 'LanguageCreateStruct');
        }

        if (!is_bool($languageCreateStruct->enabled)) {
            throw new InvalidArgumentValue('enabled', $languageCreateStruct->enabled, 'LanguageCreateStruct');
        }

        if (!$this->repository->canUser('content', 'translations', $languageCreateStruct)) {

            throw new UnauthorizedException('content', 'translations');
        }

        try {
            if ($this->loadLanguage($languageCreateStruct->languageCode) !== null) {
                throw new InvalidArgumentException('languageCreateStruct', 'language with specified language code already exists');
            }
        } catch (APINotFoundException $e) {
            // Do nothing
        }

        $createStruct = new CreateStruct(
            array(
                'languageCode' => $languageCreateStruct->languageCode,
                'name' => $languageCreateStruct->name,
                'isEnabled' => $languageCreateStruct->enabled,
            )
        );

        $this->repository->beginTransaction();
        try {
            $createdLanguage = $this->languageHandler->create($createStruct);
            $this->repository->commit();
        } catch (Exception $e) {
            $this->repository->rollback();
            throw $e;
        }

        return $this->buildDomainObject($createdLanguage);
    }

    /**
     * Changes the name of the language in the content repository.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
     *         is not string
     * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
     *
     * @param \eZ\Publish\API\Repository\Values\Content\Language $language
     * @param string $newName
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function updateLanguageName(Language $language, $newName)
    {
        if (!is_string($newName) || empty($newName)) {
            throw new InvalidArgumentValue('newName', $newName);
        }

        if (!$this->repository->canUser('content', 'translations', $language)) {

            throw new UnauthorizedException('content', 'translations');
        }

        $loadedLanguage = $this->loadLanguageById($language->id);

        $updateLanguageStruct = new SPILanguage(
            array(
                'id' => $loadedLanguage->id,
                'languageCode' => $loadedLanguage->languageCode,
                'name' => $newName,
                'isEnabled' => $loadedLanguage->enabled,
            )
        );

        $this->repository->beginTransaction();
        try {
            $this->languageHandler->update($updateLanguageStruct);
            $this->repository->commit();
        } catch (Exception $e) {
            $this->repository->rollback();
            throw $e;
        }

        return $this->loadLanguageById($loadedLanguage->id);
    }

    /**
     * Enables a language.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
     *
     * @param \eZ\Publish\API\Repository\Values\Content\Language $language
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function enableLanguage(Language $language)
    {
        if (!$this->repository->canUser('content', 'translations', $language)) {

            throw new UnauthorizedException('content', 'translations');
        }

        $loadedLanguage = $this->loadLanguageById($language->id);

        $updateLanguageStruct = new SPILanguage(
            array(
                'id' => $loadedLanguage->id,
                'languageCode' => $loadedLanguage->languageCode,
                'name' => $loadedLanguage->name,
                'isEnabled' => true,
            )
        );

        $this->repository->beginTransaction();
        try {
            $this->languageHandler->update($updateLanguageStruct);
            $this->repository->commit();
        } catch (Exception $e) {
            $this->repository->rollback();
            throw $e;
        }

        return $this->loadLanguageById($loadedLanguage->id);
    }

    /**
     * Disables a language.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
     *
     * @param \eZ\Publish\API\Repository\Values\Content\Language $language
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function disableLanguage(Language $language)
    {
        if (!$this->repository->canUser('content', 'translations', $language)) {

            throw new UnauthorizedException('content', 'translations');
        }

        $loadedLanguage = $this->loadLanguageById($language->id);

        $updateLanguageStruct = new SPILanguage(
            array(
                'id' => $loadedLanguage->id,
                'languageCode' => $loadedLanguage->languageCode,
                'name' => $loadedLanguage->name,
                'isEnabled' => false,
            )
        );

        $this->repository->beginTransaction();
        try {
            $this->languageHandler->update($updateLanguageStruct);
            $this->repository->commit();
        } catch (Exception $e) {
            $this->repository->rollback();
            throw $e;
        }

        return $this->loadLanguageById($loadedLanguage->id);
    }

    /**
     * Loads a Language from its language code ($languageCode).
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
     *         is not string
     * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if language could not be found
     *
     * @param string $languageCode
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function loadLanguage($languageCode)
    {
        if (!is_string($languageCode) || empty($languageCode)) {
            throw new InvalidArgumentException('languageCode', 'language code has an invalid value');
        }

        $language = $this->languageHandler->loadByLanguageCode($languageCode);

        return $this->buildDomainObject($language);
    }

    /**
     * Loads all Languages.
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language[]
     */
    public function loadLanguages()
    {
        $languages = $this->languageHandler->loadAll();

        $returnArray = array();
        foreach ($languages as $language) {
            $returnArray[] = $this->buildDomainObject($language);
        }

        return $returnArray;
    }

    /**
     * Loads a Language by its id ($languageId).
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if language could not be found
     *
     * @param mixed $languageId
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    public function loadLanguageById($languageId)
    {
        $language = $this->languageHandler->load($languageId);

        return $this->buildDomainObject($language);
    }

    /**
     * {@inheritdoc}
     */
    public function loadLanguageListByCode(array $languageCodes): iterable
    {
        $languages = $this->languageHandler->loadListByLanguageCodes($languageCodes);

        $returnArray = array();
        foreach ($languages as $language) {
            $returnArray[$language->languageCode] = $this->buildDomainObject($language);
        }

        return $returnArray;
    }

    /**
     * {@inheritdoc}
     */
    public function loadLanguageListById(array $languageIds): iterable
    {
        $languages = $this->languageHandler->loadList($languageIds);

        $returnArray = array();
        foreach ($languages as $language) {
            $returnArray[$language->id] = $this->buildDomainObject($language);
        }

        return $returnArray;
    }

    /**
     * Deletes  a language from content repository.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     *         if language can not be deleted
     *         because it is still assigned to some content / type / (...).
     * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
     *
     * @param \eZ\Publish\API\Repository\Values\Content\Language $language
     */
    public function deleteLanguage(Language $language)
    {
        if (!$this->repository->canUser('content', 'translations', $language)) {

            throw new UnauthorizedException('content', 'translations');
        }

        $loadedLanguage = $this->loadLanguageById($language->id);

        $this->repository->beginTransaction();
        try {
            $this->languageHandler->delete($loadedLanguage->id);
            $this->repository->commit();
        } catch (LogicException $e) {
            $this->repository->rollback();
            throw new InvalidArgumentException('language', $e->getMessage(), $e);
        } catch (Exception $e) {
            $this->repository->rollback();
            throw $e;
        }
    }

    /**
     * Returns a configured default language code.
     *
     * @return string
     */
    public function getDefaultLanguageCode()
    {
        return $this->settings['languages'][0];
    }

    /**
     * Returns a configured list of prioritized languageCodes.
     *
     *
     * @return string[]
     */
    public function getPrioritizedLanguageCodeList()
    {
        return $this->settings['languages'];
    }

    /**
     * Instantiates an object to be used for creating languages.
     *
     * @return \eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct
     */
    public function newLanguageCreateStruct()
    {
        return new LanguageCreateStruct();
    }

    /**
     * Builds Language domain object from ValueObject returned by Persistence API.
     *
     * @param \eZ\Publish\SPI\Persistence\Content\Language $spiLanguage
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Language
     */
    protected function buildDomainObject(SPILanguage $spiLanguage)
    {
        return new Language(
            array(
                'id' => $spiLanguage->id,
                'languageCode' => $spiLanguage->languageCode,
                'name' => $spiLanguage->name,
                'enabled' => $spiLanguage->isEnabled,
            )
        );
    }
}


1		<?php
2
3		/**
4		* File containing the eZ\Publish\Core\Repository\LanguageService class.
5		*
6		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7		* @license For full copyright and license information view LICENSE file distributed with this source code.
8		*/
9		namespace eZ\Publish\Core\Repository;
10
11		use eZ\Publish\API\Repository\LanguageService as LanguageServiceInterface;
12		use eZ\Publish\SPI\Persistence\Content\Language\Handler;
13		use eZ\Publish\API\Repository\Repository as RepositoryInterface;
14		use eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct;
15		use eZ\Publish\SPI\Persistence\Content\Language as SPILanguage;
16		use eZ\Publish\SPI\Persistence\Content\Language\CreateStruct;
17		use eZ\Publish\API\Repository\Values\Content\Language;
18		use eZ\Publish\API\Repository\Exceptions\NotFoundException as APINotFoundException;
19		use eZ\Publish\Core\Base\Exceptions\InvalidArgumentValue;
20		use eZ\Publish\Core\Base\Exceptions\InvalidArgumentException;
21		use eZ\Publish\Core\Base\Exceptions\UnauthorizedException;
22		use LogicException;
23		use Exception;
24
25		/**
26		* Language service, used for language operations.
27		*/
28		class LanguageService implements LanguageServiceInterface
29		{
30		/**
31		* @var \eZ\Publish\API\Repository\Repository
32		*/
33		protected $repository;
34
35		/**
36		* @var \eZ\Publish\SPI\Persistence\Content\Language\Handler
37		*/
38		protected $languageHandler;
39
40		/**
41		* @var array
42		*/
43		protected $settings;
44
45		/**
46		* Setups service with reference to repository object that created it & corresponding handler.
47		*
48		* @param \eZ\Publish\API\Repository\Repository $repository
49		* @param \eZ\Publish\SPI\Persistence\Content\Language\Handler $languageHandler
50		* @param array $settings
51		*/
52		public function __construct(RepositoryInterface $repository, Handler $languageHandler, array $settings = array())
53		{
54		$this->repository = $repository;
55		$this->languageHandler = $languageHandler;
56		// Union makes sure default settings are ignored if provided in argument
57		$this->settings = $settings + array(
58		'languages' => array('eng-GB'),
59		);
60		}
61
62		/**
63		* Creates the a new Language in the content repository.
64		*
65		* @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
66		* @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the languageCode already exists
67		*
68		* @param \eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct $languageCreateStruct
69		*
70		* @return \eZ\Publish\API\Repository\Values\Content\Language
71		*/
72		public function createLanguage(LanguageCreateStruct $languageCreateStruct)
73		{
74	View Code Duplication	if (!is_string($languageCreateStruct->name) \|\| empty($languageCreateStruct->name)) {
		0 ignored issues – show Duplication introduced 2017-04-18 15:26 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...
75		throw new InvalidArgumentValue('name', $languageCreateStruct->name, 'LanguageCreateStruct');
76		}
77
78	View Code Duplication	if (!is_string($languageCreateStruct->languageCode) \|\| empty($languageCreateStruct->languageCode)) {
		0 ignored issues – show Duplication introduced 2015-11-21 14:37 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...
79		throw new InvalidArgumentValue('languageCode', $languageCreateStruct->languageCode, 'LanguageCreateStruct');
80		}
81
82		if (!is_bool($languageCreateStruct->enabled)) {
83		throw new InvalidArgumentValue('enabled', $languageCreateStruct->enabled, 'LanguageCreateStruct');
84		}
85
86		if (!$this->repository->canUser('content', 'translations', $languageCreateStruct)) {
		0 ignored issues – show Deprecated Code introduced 2018-08-10 09:51 UTC by Report Bug Copy Issue Report The method `eZ\Publish\API\Repository\Repository::canUser()` has been deprecated with message: since 6.6, to be removed. Use PermissionResolver::canUser() instead. Indicates if the current user is allowed to perform an action given by the function on the given objects. Example: canUser( 'content', 'edit', $content, $location ); This will check edit permission on content given the specific location, if skipped if will check on all locations. Example2: canUser( 'section', 'assign', $content, $section ); Check if user has access to assign $content to $section. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
87		throw new UnauthorizedException('content', 'translations');
88		}
89
90		try {
91		if ($this->loadLanguage($languageCreateStruct->languageCode) !== null) {
92		throw new InvalidArgumentException('languageCreateStruct', 'language with specified language code already exists');
93		}
94		} catch (APINotFoundException $e) {
95		// Do nothing
96		}
97
98		$createStruct = new CreateStruct(
99		array(
100		'languageCode' => $languageCreateStruct->languageCode,
101		'name' => $languageCreateStruct->name,
102		'isEnabled' => $languageCreateStruct->enabled,
103		)
104		);
105
106		$this->repository->beginTransaction();
107		try {
108		$createdLanguage = $this->languageHandler->create($createStruct);
109		$this->repository->commit();
110		} catch (Exception $e) {
111		$this->repository->rollback();
112		throw $e;
113		}
114
115		return $this->buildDomainObject($createdLanguage);
116		}
117
118		/**
119		* Changes the name of the language in the content repository.
120		*
121		* @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
122		* is not string
123		* @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
124		*
125		* @param \eZ\Publish\API\Repository\Values\Content\Language $language
126		* @param string $newName
127		*
128		* @return \eZ\Publish\API\Repository\Values\Content\Language
129		*/
130		public function updateLanguageName(Language $language, $newName)
131		{
132		if (!is_string($newName) \|\| empty($newName)) {
133		throw new InvalidArgumentValue('newName', $newName);
134		}
135
136		if (!$this->repository->canUser('content', 'translations', $language)) {
		0 ignored issues – show Deprecated Code introduced 2018-08-10 09:51 UTC by Report Bug Copy Issue Report The method `eZ\Publish\API\Repository\Repository::canUser()` has been deprecated with message: since 6.6, to be removed. Use PermissionResolver::canUser() instead. Indicates if the current user is allowed to perform an action given by the function on the given objects. Example: canUser( 'content', 'edit', $content, $location ); This will check edit permission on content given the specific location, if skipped if will check on all locations. Example2: canUser( 'section', 'assign', $content, $section ); Check if user has access to assign $content to $section. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
137		throw new UnauthorizedException('content', 'translations');
138		}
139
140		$loadedLanguage = $this->loadLanguageById($language->id);
141
142		$updateLanguageStruct = new SPILanguage(
143		array(
144		'id' => $loadedLanguage->id,
145		'languageCode' => $loadedLanguage->languageCode,
146		'name' => $newName,
147		'isEnabled' => $loadedLanguage->enabled,
148		)
149		);
150
151		$this->repository->beginTransaction();
152		try {
153		$this->languageHandler->update($updateLanguageStruct);
154		$this->repository->commit();
155		} catch (Exception $e) {
156		$this->repository->rollback();
157		throw $e;
158		}
159
160		return $this->loadLanguageById($loadedLanguage->id);
161		}
162
163		/**
164		* Enables a language.
165		*
166		* @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
167		*
168		* @param \eZ\Publish\API\Repository\Values\Content\Language $language
169		*
170		* @return \eZ\Publish\API\Repository\Values\Content\Language
171		*/
172	View Code Duplication	public function enableLanguage(Language $language)
173		{
174		if (!$this->repository->canUser('content', 'translations', $language)) {
		0 ignored issues – show Deprecated Code introduced 2018-08-10 09:51 UTC by Report Bug Copy Issue Report The method `eZ\Publish\API\Repository\Repository::canUser()` has been deprecated with message: since 6.6, to be removed. Use PermissionResolver::canUser() instead. Indicates if the current user is allowed to perform an action given by the function on the given objects. Example: canUser( 'content', 'edit', $content, $location ); This will check edit permission on content given the specific location, if skipped if will check on all locations. Example2: canUser( 'section', 'assign', $content, $section ); Check if user has access to assign $content to $section. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
175		throw new UnauthorizedException('content', 'translations');
176		}
177
178		$loadedLanguage = $this->loadLanguageById($language->id);
179
180		$updateLanguageStruct = new SPILanguage(
181		array(
182		'id' => $loadedLanguage->id,
183		'languageCode' => $loadedLanguage->languageCode,
184		'name' => $loadedLanguage->name,
185		'isEnabled' => true,
186		)
187		);
188
189		$this->repository->beginTransaction();
190		try {
191		$this->languageHandler->update($updateLanguageStruct);
192		$this->repository->commit();
193		} catch (Exception $e) {
194		$this->repository->rollback();
195		throw $e;
196		}
197
198		return $this->loadLanguageById($loadedLanguage->id);
199		}
200
201		/**
202		* Disables a language.
203		*
204		* @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
205		*
206		* @param \eZ\Publish\API\Repository\Values\Content\Language $language
207		*
208		* @return \eZ\Publish\API\Repository\Values\Content\Language
209		*/
210	View Code Duplication	public function disableLanguage(Language $language)
211		{
212		if (!$this->repository->canUser('content', 'translations', $language)) {
		0 ignored issues – show Deprecated Code introduced 2018-08-10 09:51 UTC by Report Bug Copy Issue Report The method `eZ\Publish\API\Repository\Repository::canUser()` has been deprecated with message: since 6.6, to be removed. Use PermissionResolver::canUser() instead. Indicates if the current user is allowed to perform an action given by the function on the given objects. Example: canUser( 'content', 'edit', $content, $location ); This will check edit permission on content given the specific location, if skipped if will check on all locations. Example2: canUser( 'section', 'assign', $content, $section ); Check if user has access to assign $content to $section. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
213		throw new UnauthorizedException('content', 'translations');
214		}
215
216		$loadedLanguage = $this->loadLanguageById($language->id);
217
218		$updateLanguageStruct = new SPILanguage(
219		array(
220		'id' => $loadedLanguage->id,
221		'languageCode' => $loadedLanguage->languageCode,
222		'name' => $loadedLanguage->name,
223		'isEnabled' => false,
224		)
225		);
226
227		$this->repository->beginTransaction();
228		try {
229		$this->languageHandler->update($updateLanguageStruct);
230		$this->repository->commit();
231		} catch (Exception $e) {
232		$this->repository->rollback();
233		throw $e;
234		}
235
236		return $this->loadLanguageById($loadedLanguage->id);
237		}
238
239		/**
240		* Loads a Language from its language code ($languageCode).
241		*
242		* @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
243		* is not string
244		* @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if language could not be found
245		*
246		* @param string $languageCode
247		*
248		* @return \eZ\Publish\API\Repository\Values\Content\Language
249		*/
250		public function loadLanguage($languageCode)
251		{
252		if (!is_string($languageCode) \|\| empty($languageCode)) {
253		throw new InvalidArgumentException('languageCode', 'language code has an invalid value');
254		}
255
256		$language = $this->languageHandler->loadByLanguageCode($languageCode);
257
258		return $this->buildDomainObject($language);
259		}
260
261		/**
262		* Loads all Languages.
263		*
264		* @return \eZ\Publish\API\Repository\Values\Content\Language[]
265		*/
266		public function loadLanguages()
267		{
268		$languages = $this->languageHandler->loadAll();
269
270		$returnArray = array();
271		foreach ($languages as $language) {
272		$returnArray[] = $this->buildDomainObject($language);
273		}
274
275		return $returnArray;
276		}
277
278		/**
279		* Loads a Language by its id ($languageId).
280		*
281		* @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if language could not be found
282		*
283		* @param mixed $languageId
284		*
285		* @return \eZ\Publish\API\Repository\Values\Content\Language
286		*/
287		public function loadLanguageById($languageId)
288		{
289		$language = $this->languageHandler->load($languageId);
290
291		return $this->buildDomainObject($language);
292		}
293
294		/**
295		* {@inheritdoc}
296		*/
297		public function loadLanguageListByCode(array $languageCodes): iterable
298		{
299		$languages = $this->languageHandler->loadListByLanguageCodes($languageCodes);
300
301		$returnArray = array();
302		foreach ($languages as $language) {
303		$returnArray[$language->languageCode] = $this->buildDomainObject($language);
304		}
305
306		return $returnArray;
307		}
308
309		/**
310		* {@inheritdoc}
311		*/
312		public function loadLanguageListById(array $languageIds): iterable
313		{
314		$languages = $this->languageHandler->loadList($languageIds);
315
316		$returnArray = array();
317		foreach ($languages as $language) {
318		$returnArray[$language->id] = $this->buildDomainObject($language);
319		}
320
321		return $returnArray;
322		}
323
324		/**
325		* Deletes a language from content repository.
326		*
327		* @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
328		* if language can not be deleted
329		* because it is still assigned to some content / type / (...).
330		* @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If user does not have access to content translations
331		*
332		* @param \eZ\Publish\API\Repository\Values\Content\Language $language
333		*/
334	View Code Duplication	public function deleteLanguage(Language $language)
335		{
336		if (!$this->repository->canUser('content', 'translations', $language)) {
		0 ignored issues – show Deprecated Code introduced 2018-08-10 09:51 UTC by Report Bug Copy Issue Report The method `eZ\Publish\API\Repository\Repository::canUser()` has been deprecated with message: since 6.6, to be removed. Use PermissionResolver::canUser() instead. Indicates if the current user is allowed to perform an action given by the function on the given objects. Example: canUser( 'content', 'edit', $content, $location ); This will check edit permission on content given the specific location, if skipped if will check on all locations. Example2: canUser( 'section', 'assign', $content, $section ); Check if user has access to assign $content to $section. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
337		throw new UnauthorizedException('content', 'translations');
338		}
339
340		$loadedLanguage = $this->loadLanguageById($language->id);
341
342		$this->repository->beginTransaction();
343		try {
344		$this->languageHandler->delete($loadedLanguage->id);
345		$this->repository->commit();
346		} catch (LogicException $e) {
347		$this->repository->rollback();
348		throw new InvalidArgumentException('language', $e->getMessage(), $e);
349		} catch (Exception $e) {
350		$this->repository->rollback();
351		throw $e;
352		}
353		}
354
355		/**
356		* Returns a configured default language code.
357		*
358		* @return string
359		*/
360		public function getDefaultLanguageCode()
361		{
362		return $this->settings['languages'][0];
363		}
364
365		/**
366		* Returns a configured list of prioritized languageCodes.
367		*
368		*
369		* @return string[]
370		*/
371		public function getPrioritizedLanguageCodeList()
372		{
373		return $this->settings['languages'];
374		}
375
376		/**
377		* Instantiates an object to be used for creating languages.
378		*
379		* @return \eZ\Publish\API\Repository\Values\Content\LanguageCreateStruct
380		*/
381		public function newLanguageCreateStruct()
382		{
383		return new LanguageCreateStruct();
384		}
385
386		/**
387		* Builds Language domain object from ValueObject returned by Persistence API.
388		*
389		* @param \eZ\Publish\SPI\Persistence\Content\Language $spiLanguage
390		*
391		* @return \eZ\Publish\API\Repository\Values\Content\Language
392		*/
393		protected function buildDomainObject(SPILanguage $spiLanguage)
394		{
395		return new Language(
396		array(
397		'id' => $spiLanguage->id,
398		'languageCode' => $spiLanguage->languageCode,
399		'name' => $spiLanguage->name,
400		'enabled' => $spiLanguage->isEnabled,
401		)
402		);
403		}
404		}
405

ezsystems / ezpublish-kernel