Transfer\EzPlatform\Repository\Manager\UserGroupManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setLogger()	0	4	1
B	find()	0	19	5
A	findById()	0	4	1
B	create()	0	27	2
B	update()	0	27	3
A	createOrUpdate()	0	14	3
A	remove()	0	15	3
A	ensureDefaults()	0	10	3

<?php

/**
 * This file is part of Transfer.
 *
 * For the full copyright and license information, please view the LICENSE file located
 * in the root directory.
 */
namespace Transfer\EzPlatform\Repository\Manager;

use eZ\Publish\API\Repository\ContentService;
use eZ\Publish\API\Repository\ContentTypeService;
use eZ\Publish\API\Repository\UserService;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Transfer\Data\ObjectInterface;
use Transfer\Data\ValueObject;
use Transfer\EzPlatform\Exception\ObjectNotFoundException;
use Transfer\EzPlatform\Exception\UnsupportedObjectOperationException;
use Transfer\EzPlatform\Repository\Values\UserGroupObject;
use Transfer\EzPlatform\Repository\Manager\Type\CreatorInterface;
use Transfer\EzPlatform\Repository\Manager\Type\FinderInterface;
use Transfer\EzPlatform\Repository\Manager\Type\RemoverInterface;
use Transfer\EzPlatform\Repository\Manager\Type\UpdaterInterface;
use eZ\Publish\API\Repository\Values\User\UserGroup;
use eZ\Publish\API\Repository\Exceptions\NotFoundException;

/**
 * User Group manager.
 *
 * @internal
 */
class UserGroupManager implements LoggerAwareInterface, CreatorInterface, UpdaterInterface, RemoverInterface, FinderInterface
{
    /**
     * @var LoggerInterface
     */
    private $logger;

    /**
     * @var array
     */
    private $options;

    /**
     * @var UserService
     */
    private $userService;

    /**
     * @var ContentService
     */
    private $contentService;

    /**
     * @var ContentTypeService
     */
    private $contentTypeService;

    /**
     * @param array              $options
     * @param UserService        $userService
     * @param ContentService     $contentService
     * @param ContentTypeService $contentTypeService
     */
    public function __construct(array $options, UserService $userService, ContentService $contentService, ContentTypeService $contentTypeService)
    {
        $this->options = $options;
        $this->userService = $userService;
        $this->contentService = $contentService;
        $this->contentTypeService = $contentTypeService;
    }

    /**
     * {@inheritdoc}
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     * {@inheritdoc}
     */
    public function find(ValueObject $object, $throwException = false)
    {
        try {
            if (isset($object->data['remote_id'])) {
                $contentObject = $this->contentService->loadContentByRemoteId($object->data['remote_id']);
                $userGroup = $this->userService->loadUserGroup($contentObject->contentInfo->id);
            } elseif ($object->getProperty('id')) {
                $userGroup = $this->userService->loadUserGroup($object->getProperty('id'));
            }
        } catch (NotFoundException $notFoundException) {
            // We'll throw our own exception later instead.
        }

        if (!isset($userGroup)) {
            throw new ObjectNotFoundException(UserGroup::class, array('remote_id', 'id'));
        }

        return $userGroup;
    }

    /**
     * Shortcut to get UserGroup by id, mainly to get parent by Id.
     *
     * @param int  $id
     * @param bool $throwException
     *
     * @return UserGroup|false
     *
     * @throws NotFoundException
     */
    public function findById($id, $throwException = false)
    {
        return $this->find(new ValueObject([], ['id' => $id]), $throwException);
    }

    /**
     * {@inheritdoc}
     */
    public function create(ObjectInterface $object)
    {
        if (!$object instanceof UserGroupObject) {
            throw new UnsupportedObjectOperationException(UserGroupObject::class, get_class($object));
        }

        $this->ensureDefaults($object);

        $parentUserGroup = $this->findById($object->data['parent_id'], true);

        // Instantiate usergroup
        $contentType = $this->contentTypeService->loadContentTypeByIdentifier($object->data['content_type_identifier']);
        $userGroupCreateStruct = $this->userService->newUserGroupCreateStruct(
            $object->data['main_language_code'],
            $contentType
        );

        // Populate usergroup fields
        $object->getMapper()->mapObjectToCreateStruct($userGroupCreateStruct);

        // Create usergroup
        $userGroup = $this->userService->createUserGroup($userGroupCreateStruct, $parentUserGroup);

        $object->getMapper()->userGroupToObject($userGroup);

        return $object;
    }

    /**
     * {@inheritdoc}
     */
    public function update(ObjectInterface $object)
    {
        if (!$object instanceof UserGroupObject) {
            throw new UnsupportedObjectOperationException(UserGroupObject::class, get_class($object));
        }

        $userGroup = $this->find($object, true);

        $this->ensureDefaults($object);

        $userGroupUpdateStruct = $this->userService->newUserGroupUpdateStruct();
        $userGroupUpdateStruct->contentUpdateStruct = $this->contentService->newContentUpdateStruct();

        $object->getMapper()->mapObjectToUpdateStruct($userGroupUpdateStruct);

        $userGroup = $this->userService->updateUserGroup($userGroup, $userGroupUpdateStruct);

        if ($userGroup->parentId !== $object->data['parent_id']) {
            $newParentGroup = $this->findById($object->data['parent_id'], true);
            $this->userService->moveUserGroup($userGroup, $newParentGroup);
            $userGroup = $this->find($object, true);
        }

        $object->getMapper()->userGroupToObject($userGroup);

        return $object;
    }

    /**
     * {@inheritdoc}
     */
    public function createOrUpdate(ObjectInterface $object)
    {
        if (!$object instanceof UserGroupObject) {
            throw new UnsupportedObjectOperationException(UserGroupObject::class, get_class($object));
        }

        try {
            $this->find($object);

            return $this->update($object);
        } catch (NotFoundException $notFound) {
            return $this->create($object);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function remove(ObjectInterface $object)
    {
        if (!$object instanceof UserGroupObject) {
            throw new UnsupportedObjectOperationException(UserGroupObject::class, get_class($object));
        }

        try {
            $userGroup = $this->find($object);
            $this->userService->deleteUserGroup($userGroup);

            return true;
        } catch (NotFoundException $notFound) {
            return false;
        }
    }

    /**
     * @param UserGroupObject $userObject
     */
    private function ensureDefaults(UserGroupObject $userObject)
    {
        $defaultData = ['main_language_code'];

        foreach ($defaultData as $defaultOption) {
            if (!isset($userObject->data[$defaultOption])) {
                $userObject->data[$defaultOption] = $this->options[$defaultOption];
            }
        }
    }
}