Transfer\EzPlatform\Repository\Manager\UserManager

Complexity

Total Complexity

31

Size/Duplication

Total Lines	242
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setLogger()	0	4	1
A	find()	0	16	4
B	create()	0	31	4
B	update()	0	25	2
A	createOrUpdate()	0	14	3
A	remove()	0	14	3
B	assignUserToUserGroups()	0	20	5
A	unassignUserFromUserGroups()	0	9	3
A	getContentType()	0	8	2
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\ContentTypeService;
use eZ\Publish\API\Repository\UserService;
use eZ\Publish\API\Repository\Values\User\User;
use eZ\Publish\API\Repository\Values\User\UserGroup;
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\Values\UserObject;
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\Exceptions\NotFoundException;
use eZ\Publish\API\Repository\Exceptions\InvalidArgumentException;

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

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

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

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

    /**
     * @var UserGroupManager
     */
    private $userGroupManager;

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

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

    /**
     * {@inheritdoc}
     */
    public function find(ValueObject $object)
    {
        try {
            if (isset($object->data['username'])) {
                $user = $this->userService->loadUserByLogin($object->data['username']);
            }
        } catch (NotFoundException $notFoundException) {
            // We'll throw our own exception later instead.
        }

        if (!isset($user)) {
            throw new ObjectNotFoundException(User::class, array('username'));
        }

        return $user;
    }

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

        $this->ensureDefaults($object);

        $userCreateStruct = $this->userService->newUserCreateStruct(
            $object->data['username'],
            $object->data['email'],
            $object->data['password'],
            $object->data['main_language_code'],
            $this->getContentType($object)
        );

        $object->getMapper()->mapObjectToCreateStruct($userCreateStruct);

        $groups = [];
        foreach ($object->data['parents'] as $userGroup) {
            $userGroup = $this->userGroupManager->createOrUpdate($userGroup);
            if ($userGroup instanceof UserGroupObject) {
                $groups[] = $this->userGroupManager->find($userGroup);
            }
        }

        $user = $this->userService->createUser($userCreateStruct, $groups);
        $object->data['id'] = $user->getUserId();

        return $object;
    }

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

        $this->ensureDefaults($object);

        $user = $this->find($object);

        // Populate struct
        $userUpdateStruct = $this->userService->newUserUpdateStruct();
        $object->getMapper()->mapObjectToUpdateStruct($userUpdateStruct);

        // Update user
        $user = $this->userService->updateUser($user, $userUpdateStruct);

        // Assign user to usergroups
        $userGroups = $this->assignUserToUserGroups($user, $object->data['parents']);

        // Unassign user from usergroups
        $this->unassignUserFromUserGroups($user, $userGroups);

        return $object;
    }

    /**
     * {@inheritdoc}
     */
    public function createOrUpdate(ObjectInterface $object)
    {
        if (!$object instanceof UserObject) {
            throw new UnsupportedObjectOperationException(UserObject::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 UserObject) {
            throw new UnsupportedObjectOperationException(UserObject::class, get_class($object));
        }

        $user = $this->find($object);

        if ($user) {
            $this->userService->deleteUser($user);
        }

        return true;
    }

    /**
     * Assigns a collection of Transfer user groups from an eZ user, and returns the once who were added.
     *
     * @param User              $user
     * @param UserGroupObject[] $userGroupObjects
     *
     * @return UserGroup[]
     */
    protected function assignUserToUserGroups(User $user, array $userGroupObjects)
    {
        $ezUserGroups = [];
        foreach ($userGroupObjects as $userGroup) {
            $userGroup = $this->userGroupManager->createOrUpdate($userGroup);
            if ($userGroup instanceof UserGroupObject) {
                $ezUserGroup = $this->userGroupManager->find($userGroup);
                if ($ezUserGroup) {
                    $ezUserGroups[$ezUserGroup->id] = $ezUserGroup;
                    try {
                        $this->userService->assignUserToUserGroup($user, $ezUserGroup);
                    } catch (InvalidArgumentException $alreadyAssignedException) {
                        // Ignore error about: user already assigned to usergroup.
                    }
                }
            }
        }

        return $ezUserGroups;
    }

    /**
     * Unassigns a collection of eZ UserGroups from an eZ User.
     *
     * @param User        $user
     * @param UserGroup[] $userGroups
     */
    protected function unassignUserFromUserGroups(User $user, array $userGroups)
    {
        $existingUserGroups = $this->userService->loadUserGroupsOfUser($user);
        foreach ($existingUserGroups as $existingUserGroup) {
            if (!array_key_exists($existingUserGroup->id, $userGroups)) {
                $this->userService->unAssignUserFromUserGroup($user, $existingUserGroup);
            }
        }
    }

    /**
     * @param UserObject $object
     *
     * @return \eZ\Publish\API\Repository\Values\ContentType\ContentType|null
     */
    protected function getContentType(UserObject $object)
    {
        if (isset($object->data['content_type'])) {
            return $this->contentTypeService->loadContentTypeByIdentifier($object->data['content_type']);
        }

        return;
    }

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

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